temporalio 0.0.1 → 0.1.0

data/bridge/sdk-core/sdk-core-protos/src/lib.rs

@@ -12,7 +12,10 @@ 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;
@@ -26,7 +29,8 @@ pub mod coresdk {
     tonic::include_proto!("coresdk");
 
     use crate::temporal::api::{
-        common::v1::{ActivityType, Payload, Payloads, WorkflowExecution},
+        common::v1::{Payload, Payloads, WorkflowExecution},
+        enums::v1::WorkflowTaskFailedCause,
         failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
         workflowservice::v1::PollActivityTaskQueueResponse,
     };
@@ -66,8 +70,8 @@ pub mod coresdk {
                     "ActivityTaskCompletion(token: {}",
                     fmt_tt(&self.task_token),
                 )?;
-                if let Some(r) = self.result.as_ref() {
-                    write!(f, ", {}", r)?;
+                if let Some(r) = self.result.as_ref().and_then(|r| r.status.as_ref()) {
+                    write!(f, ", {r}")?;
                 } else {
                     write!(f, ", missing result")?;
                 }
@@ -120,21 +124,20 @@ pub mod coresdk {
             }
         }
 
-        impl Display for ActivityExecutionResult {
+        impl Display for aer::Status {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 write!(f, "ActivityExecutionResult(")?;
-                match self.status.as_ref() {
-                    None => write!(f, "missing result)"),
-                    Some(aer::Status::Completed(v)) => {
-                        write!(f, "{})", v)
+                match self {
+                    aer::Status::Completed(v) => {
+                        write!(f, "{v})")
                     }
-                    Some(aer::Status::Failed(v)) => {
-                        write!(f, "{})", v)
+                    aer::Status::Failed(v) => {
+                        write!(f, "{v})")
                     }
-                    Some(aer::Status::Cancelled(v)) => {
-                        write!(f, "{})", v)
+                    aer::Status::Cancelled(v) => {
+                        write!(f, "{v})")
                     }
-                    Some(aer::Status::WillCompleteAsync(_)) => {
+                    aer::Status::WillCompleteAsync(_) => {
                         write!(f, "Will complete async)")
                     }
                 }
@@ -145,7 +148,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, ")")
             }
@@ -155,7 +158,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, ")")
             }
@@ -165,7 +168,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, ")")
             }
@@ -186,7 +189,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:?}"),
                 }
             }
 
@@ -198,11 +201,15 @@ 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<crate::temporal::api::enums::v1::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 {
@@ -244,10 +251,6 @@ pub mod coresdk {
         }
     }
 
-    pub mod bridge {
-        tonic::include_proto!("coresdk.bridge");
-    }
-
     pub mod common {
         tonic::include_proto!("coresdk.common");
         use super::external_data::LocalActivityMarkerData;
@@ -318,7 +321,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");
 
@@ -397,6 +400,7 @@ pub mod coresdk {
             },
             temporal::api::{
                 common::v1::Header,
+                enums::v1::WorkflowTaskFailedCause,
                 history::v1::{
                     WorkflowExecutionCancelRequestedEventAttributes,
                     WorkflowExecutionSignaledEventAttributes,
@@ -405,6 +409,7 @@ pub mod coresdk {
                 query::v1::WorkflowQuery,
             },
         };
+        use prost_wkt_types::Timestamp;
         use std::{
             collections::HashMap,
             fmt::{Display, Formatter},
@@ -428,6 +433,7 @@ pub mod coresdk {
                         reason: reason as i32,
                     }),
                 )],
+                available_internal_flags: vec![],
             }
         }
 
@@ -491,7 +497,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 +534,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}"),
                 }
             }
         }
@@ -600,6 +617,7 @@ pub mod coresdk {
             attrs: WorkflowExecutionStartedEventAttributes,
             workflow_id: String,
             randomness_seed: u64,
+            start_time: Timestamp,
         ) -> StartWorkflow {
             StartWorkflow {
                 workflow_type: attrs.workflow_type.map(|wt| wt.name).unwrap_or_default(),
@@ -633,12 +651,13 @@ pub mod coresdk {
                 cron_schedule_to_schedule_interval: attrs.first_workflow_task_backoff,
                 memo: attrs.memo,
                 search_attributes: attrs.search_attributes,
+                start_time: Some(start_time),
             }
         }
     }
 
     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 {
@@ -652,7 +671,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,
+                }
             }
         }
     }
@@ -671,7 +693,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}"),
                 }
             }
         }
@@ -800,6 +822,16 @@ pub mod coresdk {
             }
         }
 
+        impl Display for ModifyWorkflowProperties {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "ModifyWorkflowProperties(upserted memo keys: {:?})",
+                    self.upserted_memo.as_ref().map(|m| m.fields.keys())
+                )
+            }
+        }
+
         impl QueryResult {
             /// Helper to construct the Temporal API query result types.
             pub fn into_components(self) -> (String, QueryResultType, Option<Payloads>, String) {
@@ -841,7 +873,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![],
+            }
         }
     }
 
@@ -895,6 +930,7 @@ pub mod coresdk {
                 status: Some(workflow_activation_completion::Status::Failed(
                     workflow_completion::Failure {
                         failure: Some(failure),
+                        force_cause: WorkflowTaskFailedCause::Unspecified as i32,
                     },
                 )),
             }
@@ -978,6 +1014,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
@@ -1015,7 +1057,7 @@ pub mod coresdk {
             )?;
             match &self.status {
                 None => write!(f, "empty")?,
-                Some(s) => write!(f, "{}", s)?,
+                Some(s) => write!(f, "{s}")?,
             };
             write!(f, ")")
         }
@@ -1025,12 +1067,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)?;
@@ -1082,21 +1124,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 {
@@ -1112,6 +1145,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 {
@@ -1182,7 +1235,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)
         }
     }
 
@@ -1320,11 +1373,6 @@ pub mod coresdk {
 // This is disgusting, but unclear to me how to avoid it. TODO: Discuss w/ prost maintainer
 pub mod temporal {
     pub mod api {
-        pub mod cluster {
-            pub mod v1 {
-                tonic::include_proto!("temporal.api.cluster.v1");
-            }
-        }
         pub mod batch {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.batch.v1");
@@ -1414,6 +1462,16 @@ pub mod temporal {
                     }
                 }
 
+                impl From<workflow_commands::ModifyWorkflowProperties> for command::Attributes {
+                    fn from(s: workflow_commands::ModifyWorkflowProperties) -> Self {
+                        Self::ModifyWorkflowPropertiesCommandAttributes(
+                            ModifyWorkflowPropertiesCommandAttributes {
+                                upserted_memo: s.upserted_memo.map(Into::into),
+                            },
+                        )
+                    }
+                }
+
                 impl From<workflow_commands::CancelTimer> for command::Attributes {
                     fn from(s: workflow_commands::CancelTimer) -> Self {
                         Self::CancelTimerCommandAttributes(CancelTimerCommandAttributes {
@@ -1533,6 +1591,7 @@ pub mod temporal {
         }
         pub mod common {
             pub mod v1 {
+                use base64::{prelude::BASE64_STANDARD, Engine};
                 use std::{
                     collections::HashMap,
                     fmt::{Display, Formatter},
@@ -1569,11 +1628,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))
                         }
                     }
                 }
@@ -1617,6 +1676,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 {
@@ -1647,14 +1726,7 @@ pub mod temporal {
 
                 impl History {
                     pub fn extract_run_id_from_start(&self) -> Result<&str, anyhow::Error> {
-                        if let Some(
-                            history_event::Attributes::WorkflowExecutionStartedEventAttributes(wes),
-                        ) = self.events.get(0).and_then(|x| x.attributes.as_ref())
-                        {
-                            Ok(&wes.original_execution_run_id)
-                        } else {
-                            bail!("First event is not WorkflowExecutionStarted?!?")
-                        }
+                        extract_original_run_id_from_events(&self.events)
                     }
 
                     /// Returns the event id of the final event in the history. Will return 0 if
@@ -1664,6 +1736,18 @@ pub mod temporal {
                     }
                 }
 
+                pub fn extract_original_run_id_from_events(
+                    events: &[HistoryEvent],
+                ) -> Result<&str, anyhow::Error> {
+                    if let Some(Attributes::WorkflowExecutionStartedEventAttributes(wes)) =
+                        events.get(0).and_then(|x| x.attributes.as_ref())
+                    {
+                        Ok(&wes.original_execution_run_id)
+                    } else {
+                        bail!("First event is not WorkflowExecutionStarted?!?")
+                    }
+                }
+
                 impl HistoryEvent {
                     /// Returns true if this is an event created to mirror a command
                     pub fn is_command_event(&self) -> bool {
@@ -1677,6 +1761,7 @@ pub mod temporal {
                             | EventType::TimerCanceled
                             | EventType::TimerStarted
                             | EventType::UpsertWorkflowSearchAttributes
+                            | EventType::WorkflowPropertiesModified
                             | EventType::WorkflowExecutionCanceled
                             | EventType::WorkflowExecutionCompleted
                             | EventType::WorkflowExecutionContinuedAsNew
@@ -1735,6 +1820,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 {
@@ -1747,6 +1841,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 {
@@ -1759,6 +1907,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");
@@ -1774,6 +1927,11 @@ pub mod temporal {
                 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;
@@ -1820,12 +1978,12 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.workflowservice.v1");
 
                 macro_rules! sched_to_start_impl {
-                    () => {
-                        /// Return the duration of the task schedule time to its start time if both
-                        /// are set and time went forward.
+                    ($sched_field:ident) => {
+                        /// Return the duration of the task schedule time (current attempt) to its
+                        /// start time if both are set and time went forward.
                         pub fn sched_to_start(&self) -> Option<Duration> {
                             if let Some((sch, st)) =
-                                self.scheduled_time.clone().zip(self.started_time.clone())
+                                self.$sched_field.clone().zip(self.started_time.clone())
                             {
                                 let sch: Result<SystemTime, _> = sch.try_into();
                                 let st: Result<SystemTime, _> = st.try_into();
@@ -1839,7 +1997,7 @@ pub mod temporal {
                 }
 
                 impl PollWorkflowTaskQueueResponse {
-                    sched_to_start_impl!();
+                    sched_to_start_impl!(scheduled_time);
                 }
 
                 impl Display for PollWorkflowTaskQueueResponse {
@@ -1881,7 +2039,7 @@ pub mod temporal {
                 }
 
                 impl PollActivityTaskQueueResponse {
-                    sched_to_start_impl!();
+                    sched_to_start_impl!(current_attempt_scheduled_time);
                 }
 
                 impl QueryWorkflowResponse {
@@ -1908,3 +2066,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");
+    }
+}

data/bridge/sdk-core/sdk-core-protos/src/task_token.rs

@@ -1,8 +1,18 @@
+use base64::{prelude::BASE64_STANDARD, Engine};
 use std::fmt::{Debug, Display, Formatter};
 
 static LOCAL_ACT_TASK_TOKEN_PREFIX: &[u8] = b"local_act_";
 
-#[derive(Hash, Eq, PartialEq, Clone, derive_more::From, derive_more::Into)]
+#[derive(
+    Hash,
+    Eq,
+    PartialEq,
+    Clone,
+    derive_more::From,
+    derive_more::Into,
+    serde::Serialize,
+    serde::Deserialize,
+)]
 /// Type-safe wrapper for task token bytes
 pub struct TaskToken(pub Vec<u8>);
 
@@ -34,5 +44,5 @@ impl Debug for TaskToken {
 }
 
 pub fn fmt_tt(tt: &[u8]) -> String {
-    base64::encode(tt)
+    BASE64_STANDARD.encode(tt)
 }