@temporalio/core-bridge 1.5.2 → 1.7.0

package/sdk-core/sdk-core-protos/src/lib.rs

@@ -12,11 +12,18 @@ mod history_info;
 mod task_token;
 
 #[cfg(feature = "history_builders")]
-pub use history_builder::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE};
+pub use history_builder::{
+    default_act_sched, default_wes_attribs, TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE,
+    DEFAULT_WORKFLOW_TYPE,
+};
 #[cfg(feature = "history_builders")]
 pub use history_info::HistoryInfo;
 pub use task_token::TaskToken;
 
+pub static ENCODING_PAYLOAD_KEY: &str = "encoding";
+pub static JSON_ENCODING_VAL: &str = "json/plain";
+pub static PATCHED_MARKER_DETAILS_KEY: &str = "patch-data";
+
 #[allow(clippy::large_enum_variant, clippy::derive_partial_eq_without_eq)]
 // I'd prefer not to do this, but there are some generated things that just don't need it.
 #[allow(missing_docs)]
@@ -25,10 +32,14 @@ pub mod coresdk {
 
     tonic::include_proto!("coresdk");
 
-    use crate::temporal::api::{
-        common::v1::{ActivityType, Payload, Payloads, WorkflowExecution},
-        failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
-        workflowservice::v1::PollActivityTaskQueueResponse,
+    use crate::{
+        temporal::api::{
+            common::v1::{Payload, Payloads, WorkflowExecution},
+            enums::v1::WorkflowTaskFailedCause,
+            failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
+            workflowservice::v1::PollActivityTaskQueueResponse,
+        },
+        ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL,
     };
     use activity_task::ActivityTask;
     use serde::{Deserialize, Serialize};
@@ -67,7 +78,7 @@ pub mod coresdk {
                     fmt_tt(&self.task_token),
                 )?;
                 if let Some(r) = self.result.as_ref().and_then(|r| r.status.as_ref()) {
-                    write!(f, ", {}", r)?;
+                    write!(f, ", {r}")?;
                 } else {
                     write!(f, ", missing result")?;
                 }
@@ -82,7 +93,10 @@ pub mod coresdk {
             common::v1::Payload,
             failure::v1::{failure, CanceledFailureInfo, Failure as APIFailure},
         };
-        use crate::temporal::api::{enums::v1::TimeoutType, failure::v1::TimeoutFailureInfo};
+        use crate::{
+            coresdk::activity_result::activity_resolution::Status,
+            temporal::api::enums::v1::TimeoutType,
+        };
         use activity_execution_result as aer;
         use std::fmt::{Display, Formatter};
 
@@ -125,13 +139,13 @@ pub mod coresdk {
                 write!(f, "ActivityExecutionResult(")?;
                 match self {
                     aer::Status::Completed(v) => {
-                        write!(f, "{})", v)
+                        write!(f, "{v})")
                     }
                     aer::Status::Failed(v) => {
-                        write!(f, "{})", v)
+                        write!(f, "{v})")
                     }
                     aer::Status::Cancelled(v) => {
-                        write!(f, "{})", v)
+                        write!(f, "{v})")
                     }
                     aer::Status::WillCompleteAsync(_) => {
                         write!(f, "Will complete async)")
@@ -144,7 +158,7 @@ pub mod coresdk {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "Success(")?;
                 if let Some(ref v) = self.result {
-                    write!(f, "{}", v)?;
+                    write!(f, "{v}")?;
                 }
                 write!(f, ")")
             }
@@ -154,7 +168,7 @@ pub mod coresdk {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "Failure(")?;
                 if let Some(ref v) = self.failure {
-                    write!(f, "{}", v)?;
+                    write!(f, "{v}")?;
                 }
                 write!(f, ")")
             }
@@ -164,7 +178,7 @@ pub mod coresdk {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "Cancellation(")?;
                 if let Some(ref v) = self.failure {
-                    write!(f, "{}", v)?;
+                    write!(f, "{v}")?;
                 }
                 write!(f, ")")
             }
@@ -185,7 +199,7 @@ pub mod coresdk {
             pub fn unwrap_ok_payload(self) -> Payload {
                 match self.status.unwrap() {
                     activity_resolution::Status::Completed(c) => c.result.unwrap(),
-                    _ => panic!("Activity was not successful"),
+                    e => panic!("Activity was not successful: {e:?}"),
                 }
             }
 
@@ -197,43 +211,42 @@ pub mod coresdk {
                 matches!(self.status, Some(activity_resolution::Status::Failed(_)))
             }
 
-            pub fn timed_out(&self) -> bool {
-                matches!(self.status, Some(activity_resolution::Status::Failed(Failure {
-                    failure: Some(ref f)
-                })) if f.is_timeout()
-                    || f.cause.as_ref().map(|c| c.is_timeout()).unwrap_or_default())
+            pub fn timed_out(&self) -> Option<TimeoutType> {
+                match self.status {
+                    Some(activity_resolution::Status::Failed(Failure {
+                        failure: Some(ref f),
+                    })) => f
+                        .is_timeout()
+                        .or_else(|| f.cause.as_ref().and_then(|c| c.is_timeout())),
+                    _ => None,
+                }
             }
 
             pub fn cancelled(&self) -> bool {
                 matches!(self.status, Some(activity_resolution::Status::Cancelled(_)))
             }
+
+            /// If this resolution is any kind of failure, return the inner failure details. Panics
+            /// if the activity succeeded, is in backoff, or this resolution is malformed.
+            pub fn unwrap_failure(self) -> APIFailure {
+                match self.status.unwrap() {
+                    Status::Failed(f) => f.failure.unwrap(),
+                    Status::Cancelled(c) => c.failure.unwrap(),
+                    _ => panic!("Actvity did not fail"),
+                }
+            }
         }
 
         impl Cancellation {
-            pub fn from_details(payload: Option<Payload>) -> Self {
+            /// Create a cancellation result from some payload. This is to be used when telling Core
+            /// that an activity completed as cancelled.
+            pub fn from_details(details: Option<Payload>) -> Self {
                 Cancellation {
                     failure: Some(APIFailure {
                         message: "Activity cancelled".to_string(),
                         failure_info: Some(failure::FailureInfo::CanceledFailureInfo(
                             CanceledFailureInfo {
-                                details: payload.map(Into::into),
-                            },
-                        )),
-                        ..Default::default()
-                    }),
-                }
-            }
-        }
-
-        impl Failure {
-            pub fn timeout(timeout_type: TimeoutType) -> Self {
-                Failure {
-                    failure: Some(APIFailure {
-                        message: "Activity timed out".to_string(),
-                        failure_info: Some(failure::FailureInfo::TimeoutFailureInfo(
-                            TimeoutFailureInfo {
-                                timeout_type: timeout_type as i32,
-                                last_heartbeat_details: None,
+                                details: details.map(Into::into),
                             },
                         )),
                         ..Default::default()
@@ -243,36 +256,47 @@ pub mod coresdk {
         }
     }
 
-    pub mod bridge {
-        tonic::include_proto!("coresdk.bridge");
-    }
-
     pub mod common {
         tonic::include_proto!("coresdk.common");
         use super::external_data::LocalActivityMarkerData;
         use crate::{
-            coresdk::{AsJsonPayloadExt, IntoPayloadsExt},
+            coresdk::{
+                external_data::PatchedMarkerData, AsJsonPayloadExt, FromJsonPayloadExt,
+                IntoPayloadsExt,
+            },
             temporal::api::common::v1::{Payload, Payloads},
+            PATCHED_MARKER_DETAILS_KEY,
         };
         use std::collections::HashMap;
 
         pub fn build_has_change_marker_details(
-            patch_id: &str,
+            patch_id: impl Into<String>,
             deprecated: bool,
-        ) -> HashMap<String, Payloads> {
+        ) -> anyhow::Result<HashMap<String, Payloads>> {
             let mut hm = HashMap::new();
-            hm.insert("patch_id".to_string(), patch_id.as_bytes().into());
-            let deprecated = deprecated as u8;
-            hm.insert("deprecated".to_string(), (&[deprecated]).into());
-            hm
+            let encoded = PatchedMarkerData {
+                id: patch_id.into(),
+                deprecated,
+            }
+            .as_json_payload()?;
+            hm.insert(PATCHED_MARKER_DETAILS_KEY.to_string(), encoded.into());
+            Ok(hm)
         }
 
         pub fn decode_change_marker_details(
             details: &HashMap<String, Payloads>,
         ) -> Option<(String, bool)> {
-            let name =
-                std::str::from_utf8(&details.get("patch_id")?.payloads.first()?.data).ok()?;
-            let deprecated = *details.get("deprecated")?.payloads.first()?.data.first()? != 0;
+            // We used to write change markers with plain bytes, so try to decode if they are
+            // json first, then fall back to that.
+            if let Some(cd) = details.get(PATCHED_MARKER_DETAILS_KEY) {
+                let decoded = PatchedMarkerData::from_json_payload(cd.payloads.first()?).ok()?;
+                return Some((decoded.id, decoded.deprecated));
+            }
+
+            let id_entry = details.get("patch_id")?.payloads.first()?;
+            let deprecated_entry = details.get("deprecated")?.payloads.first()?;
+            let name = std::str::from_utf8(&id_entry.data).ok()?;
+            let deprecated = *deprecated_entry.data.first()? != 0;
             Some((name.to_string(), deprecated))
         }
 
@@ -317,7 +341,7 @@ pub mod coresdk {
     }
 
     pub mod external_data {
-        use prost_types::{Duration, Timestamp};
+        use prost_wkt_types::{Duration, Timestamp};
         use serde::{Deserialize, Deserializer, Serialize, Serializer};
         tonic::include_proto!("coresdk.external_data");
 
@@ -396,6 +420,7 @@ pub mod coresdk {
             },
             temporal::api::{
                 common::v1::Header,
+                enums::v1::WorkflowTaskFailedCause,
                 history::v1::{
                     WorkflowExecutionCancelRequestedEventAttributes,
                     WorkflowExecutionSignaledEventAttributes,
@@ -404,7 +429,7 @@ pub mod coresdk {
                 query::v1::WorkflowQuery,
             },
         };
-        use prost_types::Timestamp;
+        use prost_wkt_types::Timestamp;
         use std::{
             collections::HashMap,
             fmt::{Display, Formatter},
@@ -428,6 +453,7 @@ pub mod coresdk {
                         reason: reason as i32,
                     }),
                 )],
+                available_internal_flags: vec![],
             }
         }
 
@@ -491,7 +517,18 @@ pub mod coresdk {
 
         impl Display for EvictionReason {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-                write!(f, "{:?}", self)
+                write!(f, "{self:?}")
+            }
+        }
+
+        impl From<EvictionReason> for WorkflowTaskFailedCause {
+            fn from(value: EvictionReason) -> Self {
+                match value {
+                    EvictionReason::Nondeterminism => {
+                        WorkflowTaskFailedCause::NonDeterministicError
+                    }
+                    _ => WorkflowTaskFailedCause::Unspecified,
+                }
             }
         }
 
@@ -517,7 +554,7 @@ pub mod coresdk {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 match &self.variant {
                     None => write!(f, "empty"),
-                    Some(v) => write!(f, "{}", v),
+                    Some(v) => write!(f, "{v}"),
                 }
             }
         }
@@ -640,7 +677,7 @@ pub mod coresdk {
     }
 
     pub mod workflow_completion {
-        use crate::temporal::api::failure;
+        use crate::temporal::api::{enums::v1::WorkflowTaskFailedCause, failure};
         tonic::include_proto!("coresdk.workflow_completion");
 
         impl workflow_activation_completion::Status {
@@ -654,7 +691,10 @@ pub mod coresdk {
 
         impl From<failure::v1::Failure> for Failure {
             fn from(f: failure::v1::Failure) -> Self {
-                Failure { failure: Some(f) }
+                Failure {
+                    failure: Some(f),
+                    force_cause: WorkflowTaskFailedCause::Unspecified as i32,
+                }
             }
         }
     }
@@ -673,7 +713,7 @@ pub mod coresdk {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 match &self.variant {
                     None => write!(f, "Empty"),
-                    Some(v) => write!(f, "{}", v),
+                    Some(v) => write!(f, "{v}"),
                 }
             }
         }
@@ -853,7 +893,10 @@ pub mod coresdk {
 
     impl From<Vec<WorkflowCommand>> for workflow_completion::Success {
         fn from(v: Vec<WorkflowCommand>) -> Self {
-            Self { commands: v }
+            Self {
+                commands: v,
+                used_internal_flags: vec![],
+            }
         }
     }
 
@@ -907,6 +950,7 @@ pub mod coresdk {
                 status: Some(workflow_activation_completion::Status::Failed(
                     workflow_completion::Failure {
                         failure: Some(failure),
+                        force_cause: WorkflowTaskFailedCause::Unspecified as i32,
                     },
                 )),
             }
@@ -990,6 +1034,12 @@ pub mod coresdk {
             }
             false
         }
+
+        pub fn add_internal_flags(&mut self, patch: u32) {
+            if let Some(workflow_activation_completion::Status::Successful(s)) = &mut self.status {
+                s.used_internal_flags.push(patch);
+            }
+        }
     }
 
     /// Makes converting outgoing lang commands into [WorkflowActivationCompletion]s easier
@@ -1027,7 +1077,7 @@ pub mod coresdk {
             )?;
             match &self.status {
                 None => write!(f, "empty")?,
-                Some(s) => write!(f, "{}", s)?,
+                Some(s) => write!(f, "{s}")?,
             };
             write!(f, ")")
         }
@@ -1037,12 +1087,12 @@ pub mod coresdk {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
             match self {
                 workflow_activation_completion::Status::Successful(
-                    workflow_completion::Success { commands },
+                    workflow_completion::Success { commands, .. },
                 ) => {
                     write!(f, "Success(")?;
                     let mut written = 0;
                     for c in commands {
-                        write!(f, "{} ", c)?;
+                        write!(f, "{c} ")?;
                         written += 1;
                         if written >= 10 && written < commands.len() {
                             write!(f, "... {} more", commands.len() - written)?;
@@ -1094,21 +1144,12 @@ pub mod coresdk {
         }
     }
 
-    impl From<String> for ActivityType {
-        fn from(name: String) -> Self {
-            Self { name }
-        }
-    }
-
-    impl From<ActivityType> for String {
-        fn from(at: ActivityType) -> Self {
-            at.name
-        }
-    }
-
     impl Failure {
-        pub fn is_timeout(&self) -> bool {
-            matches!(self.failure_info, Some(FailureInfo::TimeoutFailureInfo(_)))
+        pub fn is_timeout(&self) -> Option<crate::temporal::api::enums::v1::TimeoutType> {
+            match &self.failure_info {
+                Some(FailureInfo::TimeoutFailureInfo(ti)) => Some(ti.timeout_type()),
+                _ => None,
+            }
         }
 
         pub fn application_failure(message: String, non_retryable: bool) -> Self {
@@ -1124,6 +1165,26 @@ pub mod coresdk {
             }
         }
 
+        pub fn application_failure_from_error(ae: anyhow::Error, non_retryable: bool) -> Self {
+            Self {
+                failure_info: Some(FailureInfo::ApplicationFailureInfo(
+                    ApplicationFailureInfo {
+                        non_retryable,
+                        ..Default::default()
+                    },
+                )),
+                ..ae.chain()
+                    .rfold(None, |cause, e| {
+                        Some(Self {
+                            message: e.to_string(),
+                            cause: cause.map(Box::new),
+                            ..Default::default()
+                        })
+                    })
+                    .unwrap_or_default()
+            }
+        }
+
         /// Extracts an ApplicationFailureInfo from a Failure instance if it exists
         pub fn maybe_application_failure(&self) -> Option<&ApplicationFailureInfo> {
             if let Failure {
@@ -1194,7 +1255,7 @@ pub mod coresdk {
 
     impl From<anyhow::Error> for Failure {
         fn from(ae: anyhow::Error) -> Self {
-            Failure::application_failure(ae.to_string(), false)
+            Failure::application_failure_from_error(ae, false)
         }
     }
 
@@ -1271,7 +1332,10 @@ pub mod coresdk {
         fn as_json_payload(&self) -> anyhow::Result<Payload> {
             let as_json = serde_json::to_string(self)?;
             let mut metadata = HashMap::new();
-            metadata.insert("encoding".to_string(), b"json/plain".to_vec());
+            metadata.insert(
+                ENCODING_PAYLOAD_KEY.to_string(),
+                JSON_ENCODING_VAL.as_bytes().to_vec(),
+            );
             Ok(Payload {
                 metadata,
                 data: as_json.into_bytes(),
@@ -1287,10 +1351,7 @@ pub mod coresdk {
         T: for<'de> Deserialize<'de>,
     {
         fn from_json_payload(payload: &Payload) -> Result<Self, PayloadDeserializeErr> {
-            if !matches!(
-                payload.metadata.get("encoding").map(|v| v.as_slice()),
-                Some(b"json/plain")
-            ) {
+            if !payload.is_json_payload() {
                 return Err(PayloadDeserializeErr::DeserializerDoesNotHandle);
             }
             let payload_str = std::str::from_utf8(&payload.data).map_err(anyhow::Error::from)?;
@@ -1550,6 +1611,8 @@ pub mod temporal {
         }
         pub mod common {
             pub mod v1 {
+                use crate::{ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL};
+                use base64::{prelude::BASE64_STANDARD, Engine};
                 use std::{
                     collections::HashMap,
                     fmt::{Display, Formatter},
@@ -1564,7 +1627,7 @@ pub mod temporal {
                         // TODO: Set better encodings, whole data converter deal. Setting anything
                         //  for now at least makes it show up in the web UI.
                         let mut metadata = HashMap::new();
-                        metadata.insert("encoding".to_string(), b"binary/plain".to_vec());
+                        metadata.insert(ENCODING_PAYLOAD_KEY.to_string(), b"binary/plain".to_vec());
                         Self {
                             metadata,
                             data: v.as_ref().to_vec(),
@@ -1577,6 +1640,13 @@ pub mod temporal {
                     pub fn as_slice(&self) -> &[u8] {
                         self.data.as_slice()
                     }
+
+                    pub fn is_json_payload(&self) -> bool {
+                        self.metadata
+                            .get(ENCODING_PAYLOAD_KEY)
+                            .map(|v| v.as_slice() == JSON_ENCODING_VAL.as_bytes())
+                            .unwrap_or_default()
+                    }
                 }
 
                 impl Display for Payload {
@@ -1586,11 +1656,11 @@ pub mod temporal {
                             write!(
                                 f,
                                 "[{}..{}]",
-                                base64::encode(windows.next().unwrap_or_default()),
-                                base64::encode(windows.next_back().unwrap_or_default())
+                                BASE64_STANDARD.encode(windows.next().unwrap_or_default()),
+                                BASE64_STANDARD.encode(windows.next_back().unwrap_or_default())
                             )
                         } else {
-                            write!(f, "[{}]", base64::encode(&self.data))
+                            write!(f, "[{}]", BASE64_STANDARD.encode(&self.data))
                         }
                     }
                 }
@@ -1634,6 +1704,26 @@ pub mod temporal {
                         }
                     }
                 }
+
+                impl From<String> for ActivityType {
+                    fn from(name: String) -> Self {
+                        Self { name }
+                    }
+                }
+
+                impl From<&str> for ActivityType {
+                    fn from(name: &str) -> Self {
+                        Self {
+                            name: name.to_string(),
+                        }
+                    }
+                }
+
+                impl From<ActivityType> for String {
+                    fn from(at: ActivityType) -> Self {
+                        at.name
+                    }
+                }
             }
         }
         pub mod enums {
@@ -1699,6 +1789,7 @@ pub mod temporal {
                             | EventType::TimerCanceled
                             | EventType::TimerStarted
                             | EventType::UpsertWorkflowSearchAttributes
+                            | EventType::WorkflowPropertiesModified
                             | EventType::WorkflowExecutionCanceled
                             | EventType::WorkflowExecutionCompleted
                             | EventType::WorkflowExecutionContinuedAsNew
@@ -1757,6 +1848,15 @@ pub mod temporal {
                             _ => false,
                         }
                     }
+
+                    pub fn is_wft_closed_event(&self) -> bool {
+                        match self.event_type() {
+                            EventType::WorkflowTaskCompleted => true,
+                            EventType::WorkflowTaskFailed => true,
+                            EventType::WorkflowTaskTimedOut => true,
+                            _ => false,
+                        }
+                    }
                 }
 
                 impl Display for HistoryEvent {
@@ -1769,6 +1869,60 @@ pub mod temporal {
                         )
                     }
                 }
+
+                impl Attributes {
+                    pub fn event_type(&self) -> EventType {
+                        // I just absolutely _love_ this
+                        match self {
+                            Attributes::WorkflowExecutionStartedEventAttributes(_) => {EventType::WorkflowExecutionStarted}
+                            Attributes::WorkflowExecutionCompletedEventAttributes(_) => {EventType::WorkflowExecutionCompleted}
+                            Attributes::WorkflowExecutionFailedEventAttributes(_) => {EventType::WorkflowExecutionFailed}
+                            Attributes::WorkflowExecutionTimedOutEventAttributes(_) => {EventType::WorkflowExecutionTimedOut}
+                            Attributes::WorkflowTaskScheduledEventAttributes(_) => {EventType::WorkflowTaskScheduled}
+                            Attributes::WorkflowTaskStartedEventAttributes(_) => {EventType::WorkflowTaskStarted}
+                            Attributes::WorkflowTaskCompletedEventAttributes(_) => {EventType::WorkflowTaskCompleted}
+                            Attributes::WorkflowTaskTimedOutEventAttributes(_) => {EventType::WorkflowTaskTimedOut}
+                            Attributes::WorkflowTaskFailedEventAttributes(_) => {EventType::WorkflowTaskFailed}
+                            Attributes::ActivityTaskScheduledEventAttributes(_) => {EventType::ActivityTaskScheduled}
+                            Attributes::ActivityTaskStartedEventAttributes(_) => {EventType::ActivityTaskStarted}
+                            Attributes::ActivityTaskCompletedEventAttributes(_) => {EventType::ActivityTaskCompleted}
+                            Attributes::ActivityTaskFailedEventAttributes(_) => {EventType::ActivityTaskFailed}
+                            Attributes::ActivityTaskTimedOutEventAttributes(_) => {EventType::ActivityTaskTimedOut}
+                            Attributes::TimerStartedEventAttributes(_) => {EventType::TimerStarted}
+                            Attributes::TimerFiredEventAttributes(_) => {EventType::TimerFired}
+                            Attributes::ActivityTaskCancelRequestedEventAttributes(_) => {EventType::ActivityTaskCancelRequested}
+                            Attributes::ActivityTaskCanceledEventAttributes(_) => {EventType::ActivityTaskCanceled}
+                            Attributes::TimerCanceledEventAttributes(_) => {EventType::TimerCanceled}
+                            Attributes::MarkerRecordedEventAttributes(_) => {EventType::MarkerRecorded}
+                            Attributes::WorkflowExecutionSignaledEventAttributes(_) => {EventType::WorkflowExecutionSignaled}
+                            Attributes::WorkflowExecutionTerminatedEventAttributes(_) => {EventType::WorkflowExecutionTerminated}
+                            Attributes::WorkflowExecutionCancelRequestedEventAttributes(_) => {EventType::WorkflowExecutionCancelRequested}
+                            Attributes::WorkflowExecutionCanceledEventAttributes(_) => {EventType::WorkflowExecutionCanceled}
+                            Attributes::RequestCancelExternalWorkflowExecutionInitiatedEventAttributes(_) => {EventType::RequestCancelExternalWorkflowExecutionInitiated}
+                            Attributes::RequestCancelExternalWorkflowExecutionFailedEventAttributes(_) => {EventType::RequestCancelExternalWorkflowExecutionFailed}
+                            Attributes::ExternalWorkflowExecutionCancelRequestedEventAttributes(_) => {EventType::ExternalWorkflowExecutionCancelRequested}
+                            Attributes::WorkflowExecutionContinuedAsNewEventAttributes(_) => {EventType::WorkflowExecutionContinuedAsNew}
+                            Attributes::StartChildWorkflowExecutionInitiatedEventAttributes(_) => {EventType::StartChildWorkflowExecutionInitiated}
+                            Attributes::StartChildWorkflowExecutionFailedEventAttributes(_) => {EventType::StartChildWorkflowExecutionFailed}
+                            Attributes::ChildWorkflowExecutionStartedEventAttributes(_) => {EventType::ChildWorkflowExecutionStarted}
+                            Attributes::ChildWorkflowExecutionCompletedEventAttributes(_) => {EventType::ChildWorkflowExecutionCompleted}
+                            Attributes::ChildWorkflowExecutionFailedEventAttributes(_) => {EventType::ChildWorkflowExecutionFailed}
+                            Attributes::ChildWorkflowExecutionCanceledEventAttributes(_) => {EventType::ChildWorkflowExecutionCanceled}
+                            Attributes::ChildWorkflowExecutionTimedOutEventAttributes(_) => {EventType::ChildWorkflowExecutionTimedOut}
+                            Attributes::ChildWorkflowExecutionTerminatedEventAttributes(_) => {EventType::ChildWorkflowExecutionTerminated}
+                            Attributes::SignalExternalWorkflowExecutionInitiatedEventAttributes(_) => {EventType::SignalExternalWorkflowExecutionInitiated}
+                            Attributes::SignalExternalWorkflowExecutionFailedEventAttributes(_) => {EventType::SignalExternalWorkflowExecutionFailed}
+                            Attributes::ExternalWorkflowExecutionSignaledEventAttributes(_) => {EventType::ExternalWorkflowExecutionSignaled}
+                            Attributes::UpsertWorkflowSearchAttributesEventAttributes(_) => {EventType::UpsertWorkflowSearchAttributes}
+                            Attributes::WorkflowExecutionUpdateRejectedEventAttributes(_) => {EventType::WorkflowExecutionUpdateRejected}
+                            Attributes::WorkflowExecutionUpdateAcceptedEventAttributes(_) => {EventType::WorkflowExecutionUpdateAccepted}
+                            Attributes::WorkflowExecutionUpdateCompletedEventAttributes(_) => {EventType::WorkflowExecutionUpdateCompleted}
+                            Attributes::WorkflowPropertiesModifiedExternallyEventAttributes(_) => {EventType::WorkflowPropertiesModifiedExternally}
+                            Attributes::ActivityPropertiesModifiedExternallyEventAttributes(_) => {EventType::ActivityPropertiesModifiedExternally}
+                            Attributes::WorkflowPropertiesModifiedEventAttributes(_) => {EventType::WorkflowPropertiesModified}
+                        }
+                    }
+                }
             }
         }
         pub mod namespace {
@@ -1781,6 +1935,11 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.operatorservice.v1");
             }
         }
+        pub mod protocol {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.protocol.v1");
+            }
+        }
         pub mod query {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.query.v1");
@@ -1792,10 +1951,16 @@ pub mod temporal {
             }
         }
         pub mod schedule {
+            #[allow(rustdoc::invalid_html_tags)]
             pub mod v1 {
                 tonic::include_proto!("temporal.api.schedule.v1");
             }
         }
+        pub mod sdk {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.sdk.v1");
+            }
+        }
         pub mod taskqueue {
             pub mod v1 {
                 use crate::temporal::api::enums::v1::TaskQueueKind;
@@ -1930,3 +2095,23 @@ pub mod grpc {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::temporal::api::failure::v1::Failure;
+    use anyhow::anyhow;
+
+    #[test]
+    fn anyhow_to_failure_conversion() {
+        let no_causes: Failure = anyhow!("no causes").into();
+        assert_eq!(no_causes.cause, None);
+        assert_eq!(no_causes.message, "no causes");
+        let orig = anyhow!("fail 1");
+        let mid = orig.context("fail 2");
+        let top = mid.context("fail 3");
+        let as_fail: Failure = top.into();
+        assert_eq!(as_fail.message, "fail 3");
+        assert_eq!(as_fail.cause.as_ref().unwrap().message, "fail 2");
+        assert_eq!(as_fail.cause.unwrap().cause.unwrap().message, "fail 1");
+    }
+}