@temporalio/core-bridge 0.16.4 → 0.18.0

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

@@ -2,6 +2,21 @@
 //! the Temporal Core SDK. Language SDK authors can generate structs using the proto definitions
 //! that will match the generated structs in this module.
 
+pub mod constants;
+pub mod utilities;
+
+#[cfg(feature = "history_builders")]
+mod history_builder;
+#[cfg(feature = "history_builders")]
+mod history_info;
+mod task_token;
+
+#[cfg(feature = "history_builders")]
+pub use history_builder::{default_wes_attribs, TestHistoryBuilder, DEFAULT_WORKFLOW_TYPE};
+#[cfg(feature = "history_builders")]
+pub use history_info::HistoryInfo;
+pub use task_token::TaskToken;
+
 #[allow(clippy::large_enum_variant)]
 // I'd prefer not to do this, but there are some generated things that just don't need it.
 #[allow(missing_docs)]
@@ -15,32 +30,27 @@ pub mod coresdk {
         failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
         workflowservice::v1::PollActivityTaskQueueResponse,
     };
-    use activity_result::ActivityResult;
     use activity_task::ActivityTask;
     use common::Payload;
+    use serde::{Deserialize, Serialize};
     use std::{
         collections::HashMap,
         convert::TryFrom,
         fmt::{Display, Formatter},
         iter::FromIterator,
     };
-    use workflow_activation::{wf_activation_job, WfActivationJob};
+    use workflow_activation::{workflow_activation_job, WorkflowActivationJob};
     use workflow_commands::{workflow_command, workflow_command::Variant, WorkflowCommand};
-    use workflow_completion::{wf_activation_completion, WfActivationCompletion};
+    use workflow_completion::{workflow_activation_completion, WorkflowActivationCompletion};
 
     #[allow(clippy::module_inception)]
     pub mod activity_task {
         tonic::include_proto!("coresdk.activity_task");
 
         impl ActivityTask {
-            pub fn cancel_from_ids(
-                task_token: Vec<u8>,
-                activity_id: String,
-                reason: ActivityCancelReason,
-            ) -> Self {
+            pub fn cancel_from_ids(task_token: Vec<u8>, reason: ActivityCancelReason) -> Self {
                 Self {
                     task_token,
-                    activity_id,
                     variant: Some(activity_task::Variant::Cancel(Cancel {
                         reason: reason as i32,
                     })),
@@ -52,41 +62,134 @@ pub mod coresdk {
     pub mod activity_result {
         tonic::include_proto!("coresdk.activity_result");
         use super::{
-            super::temporal::api::failure::v1::{
-                failure, CanceledFailureInfo, Failure as APIFailure,
+            super::temporal::api::{
+                common::v1::Payload as APIPayload,
+                failure::v1::{failure, CanceledFailureInfo, Failure as APIFailure},
             },
             common::Payload,
         };
+        use crate::temporal::api::{enums::v1::TimeoutType, failure::v1::TimeoutFailureInfo};
+        use activity_execution_result as aer;
 
-        impl ActivityResult {
-            pub fn cancel_from_details(payload: Option<Payload>) -> Self {
+        impl ActivityExecutionResult {
+            pub const fn ok(result: Payload) -> Self {
                 Self {
-                    status: Some(activity_result::Status::Cancelled(Cancellation {
-                        failure: Some(APIFailure {
-                            // CanceledFailure
-                            message: "Activity cancelled".to_string(),
-                            failure_info: Some(failure::FailureInfo::CanceledFailureInfo(
-                                CanceledFailureInfo {
-                                    details: payload.map(Into::into),
-                                },
-                            )),
-                            ..Default::default()
-                        }),
+                    status: Some(aer::Status::Completed(Success {
+                        result: Some(result),
+                    })),
+                }
+            }
+
+            pub fn fail(fail: APIFailure) -> Self {
+                Self {
+                    status: Some(aer::Status::Failed(Failure {
+                        failure: Some(fail),
                     })),
                 }
             }
+
+            pub fn cancel_from_details(payload: Option<Payload>) -> Self {
+                Self {
+                    status: Some(aer::Status::Cancelled(Cancellation::from_details(payload))),
+                }
+            }
+
             pub const fn will_complete_async() -> Self {
                 Self {
-                    status: Some(activity_result::Status::WillCompleteAsync(
-                        WillCompleteAsync {},
-                    )),
+                    status: Some(aer::Status::WillCompleteAsync(WillCompleteAsync {})),
                 }
             }
+
+            pub fn is_cancelled(&self) -> bool {
+                matches!(self.status, Some(aer::Status::Cancelled(_)))
+            }
         }
+
+        impl From<Result<APIPayload, APIFailure>> for ActivityExecutionResult {
+            fn from(r: Result<APIPayload, APIFailure>) -> Self {
+                Self {
+                    status: match r {
+                        Ok(p) => Some(aer::Status::Completed(Success {
+                            result: Some(p.into()),
+                        })),
+                        Err(f) => Some(aer::Status::Failed(Failure { failure: Some(f) })),
+                    },
+                }
+            }
+        }
+
+        impl ActivityResolution {
+            pub fn unwrap_ok_payload(self) -> Payload {
+                match self.status.unwrap() {
+                    activity_resolution::Status::Completed(c) => c.result.unwrap(),
+                    _ => panic!("Activity was not successful"),
+                }
+            }
+
+            pub fn completed_ok(&self) -> bool {
+                matches!(self.status, Some(activity_resolution::Status::Completed(_)))
+            }
+
+            pub fn failed(&self) -> bool {
+                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())
+            }
+
+            pub fn cancelled(&self) -> bool {
+                matches!(self.status, Some(activity_resolution::Status::Cancelled(_)))
+            }
+        }
+
+        impl Cancellation {
+            pub fn from_details(payload: 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,
+                            },
+                        )),
+                        ..Default::default()
+                    }),
+                }
+            }
+        }
+    }
+
+    pub mod bridge {
+        tonic::include_proto!("coresdk.bridge");
     }
+
     pub mod common {
         tonic::include_proto!("coresdk.common");
-        use crate::temporal::api::common::v1::Payloads;
+        use super::external_data::LocalActivityMarkerData;
+        use crate::{
+            coresdk::{AsJsonPayloadExt, IntoPayloadsExt},
+            temporal::api::common::v1::{Payload as ApiPayload, Payloads},
+        };
         use std::collections::HashMap;
 
         impl<T> From<T> for Payload
@@ -126,11 +229,122 @@ pub mod coresdk {
             let deprecated = *details.get("deprecated")?.payloads.get(0)?.data.get(0)? != 0;
             Some((name.to_string(), deprecated))
         }
+
+        pub fn build_local_activity_marker_details(
+            metadata: LocalActivityMarkerData,
+            result: Option<Payload>,
+        ) -> HashMap<String, Payloads> {
+            let mut hm = HashMap::new();
+            // It would be more efficient for this to be proto binary, but then it shows up as
+            // meaningless in the Temporal UI...
+            if let Some(jsonified) = metadata.as_json_payload().into_payloads() {
+                hm.insert("data".to_string(), jsonified);
+            }
+            if let Some(res) = result {
+                hm.insert("result".to_string(), res.into());
+            }
+            hm
+        }
+
+        /// Given a marker detail map, returns just the local activity info, but not the payload.
+        /// This is fairly inexpensive. Deserializing the whole payload may not be.
+        pub fn extract_local_activity_marker_data(
+            details: &HashMap<String, Payloads>,
+        ) -> Option<LocalActivityMarkerData> {
+            details
+                .get("data")
+                .and_then(|p| p.payloads.get(0))
+                .and_then(|p| std::str::from_utf8(&p.data).ok())
+                .and_then(|s| serde_json::from_str(s).ok())
+        }
+
+        /// Given a marker detail map, returns the local activity info and the result payload
+        /// if they are found and the marker data is well-formed. This removes the data from the
+        /// map.
+        pub fn extract_local_activity_marker_details(
+            details: &mut HashMap<String, Payloads>,
+        ) -> (Option<LocalActivityMarkerData>, Option<ApiPayload>) {
+            let data = extract_local_activity_marker_data(details);
+            let result = details.remove("result").and_then(|mut p| p.payloads.pop());
+            (data, result)
+        }
+    }
+
+    pub mod external_data {
+        use prost_types::{Duration, Timestamp};
+        use serde::{Deserialize, Deserializer, Serialize, Serializer};
+        tonic::include_proto!("coresdk.external_data");
+
+        // Buncha hullaballoo because prost types aren't serde compat.
+        // See https://github.com/tokio-rs/prost/issues/75 which hilariously Chad opened ages ago
+
+        #[derive(Serialize, Deserialize)]
+        #[serde(remote = "Timestamp")]
+        struct TimestampDef {
+            pub seconds: i64,
+            pub nanos: i32,
+        }
+        mod opt_timestamp {
+            use super::*;
+
+            pub fn serialize<S>(value: &Option<Timestamp>, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                #[derive(Serialize)]
+                struct Helper<'a>(#[serde(with = "TimestampDef")] &'a Timestamp);
+
+                value.as_ref().map(Helper).serialize(serializer)
+            }
+
+            pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Timestamp>, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                #[derive(Deserialize)]
+                struct Helper(#[serde(with = "TimestampDef")] Timestamp);
+
+                let helper = Option::deserialize(deserializer)?;
+                Ok(helper.map(|Helper(external)| external))
+            }
+        }
+
+        // Luckily Duration is also stored the exact same way
+        #[derive(Serialize, Deserialize)]
+        #[serde(remote = "Duration")]
+        struct DurationDef {
+            pub seconds: i64,
+            pub nanos: i32,
+        }
+        mod opt_duration {
+            use super::*;
+
+            pub fn serialize<S>(value: &Option<Duration>, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer,
+            {
+                #[derive(Serialize)]
+                struct Helper<'a>(#[serde(with = "DurationDef")] &'a Duration);
+
+                value.as_ref().map(Helper).serialize(serializer)
+            }
+
+            pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Duration>, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                #[derive(Deserialize)]
+                struct Helper(#[serde(with = "DurationDef")] Duration);
+
+                let helper = Option::deserialize(deserializer)?;
+                Ok(helper.map(|Helper(external)| external))
+            }
+        }
     }
 
     pub mod workflow_activation {
         use crate::{
-            coresdk::FromPayloadsExt,
+            coresdk::{workflow_activation::remove_from_cache::EvictionReason, FromPayloadsExt},
             temporal::api::history::v1::{
                 WorkflowExecutionCancelRequestedEventAttributes,
                 WorkflowExecutionSignaledEventAttributes,
@@ -139,13 +353,21 @@ pub mod coresdk {
         use std::fmt::{Display, Formatter};
 
         tonic::include_proto!("coresdk.workflow_activation");
-        pub fn create_evict_activation(run_id: String, reason: String) -> WfActivation {
-            WfActivation {
+
+        pub fn create_evict_activation(
+            run_id: String,
+            message: String,
+            reason: EvictionReason,
+        ) -> WorkflowActivation {
+            WorkflowActivation {
                 timestamp: None,
                 run_id,
                 is_replaying: false,
-                jobs: vec![WfActivationJob::from(
-                    wf_activation_job::Variant::RemoveFromCache(RemoveFromCache { reason }),
+                jobs: vec![WorkflowActivationJob::from(
+                    workflow_activation_job::Variant::RemoveFromCache(RemoveFromCache {
+                        message,
+                        reason: reason as i32,
+                    }),
                 )],
             }
         }
@@ -153,27 +375,27 @@ pub mod coresdk {
         pub fn create_query_activation(
             run_id: String,
             queries: impl IntoIterator<Item = QueryWorkflow>,
-        ) -> WfActivation {
-            WfActivation {
+        ) -> WorkflowActivation {
+            WorkflowActivation {
                 timestamp: None,
                 run_id,
                 is_replaying: false,
                 jobs: queries
                     .into_iter()
-                    .map(|qr| wf_activation_job::Variant::QueryWorkflow(qr).into())
+                    .map(|qr| workflow_activation_job::Variant::QueryWorkflow(qr).into())
                     .collect(),
             }
         }
 
-        impl WfActivation {
+        impl WorkflowActivation {
             /// Returns the index of the eviction job if this activation contains one. If present
             /// it should always be the last job in the list.
             pub fn eviction_index(&self) -> Option<usize> {
                 self.jobs.iter().position(|j| {
                     matches!(
                         j,
-                        WfActivationJob {
-                            variant: Some(wf_activation_job::Variant::RemoveFromCache(_))
+                        WorkflowActivationJob {
+                            variant: Some(workflow_activation_job::Variant::RemoveFromCache(_))
                         }
                     )
                 })
@@ -183,11 +405,46 @@ pub mod coresdk {
             pub fn is_only_eviction(&self) -> bool {
                 self.jobs.len() == 1 && self.eviction_index().is_some()
             }
+
+            /// Returns eviction reason if this activation has an evict job
+            pub fn eviction_reason(&self) -> Option<EvictionReason> {
+                self.jobs.iter().find_map(|j| {
+                    if let Some(workflow_activation_job::Variant::RemoveFromCache(ref rj)) =
+                        j.variant
+                    {
+                        EvictionReason::from_i32(rj.reason)
+                    } else {
+                        None
+                    }
+                })
+            }
+
+            /// Append an eviction job to the joblist
+            pub fn append_evict_job(&mut self, evict_job: RemoveFromCache) {
+                if let Some(last_job) = self.jobs.last() {
+                    if matches!(
+                        last_job.variant,
+                        Some(workflow_activation_job::Variant::RemoveFromCache(_))
+                    ) {
+                        return;
+                    }
+                }
+                let evict_job = WorkflowActivationJob::from(
+                    workflow_activation_job::Variant::RemoveFromCache(evict_job),
+                );
+                self.jobs.push(evict_job);
+            }
+        }
+
+        impl Display for EvictionReason {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "{:?}", self)
+            }
         }
 
-        impl Display for WfActivation {
+        impl Display for WorkflowActivation {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-                write!(f, "WfActivation(")?;
+                write!(f, "WorkflowActivation(")?;
                 write!(f, "run_id: {}, ", self.run_id)?;
                 write!(f, "is_replaying: {}, ", self.is_replaying)?;
                 write!(
@@ -203,45 +460,57 @@ pub mod coresdk {
             }
         }
 
-        impl Display for WfActivationJob {
+        impl Display for WorkflowActivationJob {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 match &self.variant {
-                    None => write!(f, "Empty"),
-                    Some(v) => match v {
-                        wf_activation_job::Variant::StartWorkflow(_) => write!(f, "StartWorkflow"),
-                        wf_activation_job::Variant::FireTimer(_) => write!(f, "FireTimer"),
-                        wf_activation_job::Variant::UpdateRandomSeed(_) => {
-                            write!(f, "UpdateRandomSeed")
-                        }
-                        wf_activation_job::Variant::QueryWorkflow(_) => write!(f, "QueryWorkflow"),
-                        wf_activation_job::Variant::CancelWorkflow(_) => {
-                            write!(f, "CancelWorkflow")
-                        }
-                        wf_activation_job::Variant::SignalWorkflow(_) => {
-                            write!(f, "SignalWorkflow")
-                        }
-                        wf_activation_job::Variant::ResolveActivity(_) => {
-                            write!(f, "ResolveActivity")
-                        }
-                        wf_activation_job::Variant::NotifyHasPatch(_) => {
-                            write!(f, "NotifyHasPatch")
-                        }
-                        wf_activation_job::Variant::ResolveChildWorkflowExecutionStart(_) => {
-                            write!(f, "ResolveChildWorkflowExecutionStart")
-                        }
-                        wf_activation_job::Variant::ResolveChildWorkflowExecution(_) => {
-                            write!(f, "ResolveChildWorkflowExecution")
-                        }
-                        wf_activation_job::Variant::ResolveSignalExternalWorkflow(_) => {
-                            write!(f, "ResolveSignalExternalWorkflow")
-                        }
-                        wf_activation_job::Variant::RemoveFromCache(_) => {
-                            write!(f, "RemoveFromCache")
-                        }
-                        wf_activation_job::Variant::ResolveRequestCancelExternalWorkflow(_) => {
-                            write!(f, "ResolveRequestCancelExternalWorkflow")
-                        }
-                    },
+                    None => write!(f, "empty"),
+                    Some(v) => write!(f, "{}", v),
+                }
+            }
+        }
+
+        impl Display for workflow_activation_job::Variant {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                match self {
+                    workflow_activation_job::Variant::StartWorkflow(_) => {
+                        write!(f, "StartWorkflow")
+                    }
+                    workflow_activation_job::Variant::FireTimer(t) => {
+                        write!(f, "FireTimer({})", t.seq)
+                    }
+                    workflow_activation_job::Variant::UpdateRandomSeed(_) => {
+                        write!(f, "UpdateRandomSeed")
+                    }
+                    workflow_activation_job::Variant::QueryWorkflow(_) => {
+                        write!(f, "QueryWorkflow")
+                    }
+                    workflow_activation_job::Variant::CancelWorkflow(_) => {
+                        write!(f, "CancelWorkflow")
+                    }
+                    workflow_activation_job::Variant::SignalWorkflow(_) => {
+                        write!(f, "SignalWorkflow")
+                    }
+                    workflow_activation_job::Variant::ResolveActivity(r) => {
+                        write!(f, "ResolveActivity({})", r.seq)
+                    }
+                    workflow_activation_job::Variant::NotifyHasPatch(_) => {
+                        write!(f, "NotifyHasPatch")
+                    }
+                    workflow_activation_job::Variant::ResolveChildWorkflowExecutionStart(_) => {
+                        write!(f, "ResolveChildWorkflowExecutionStart")
+                    }
+                    workflow_activation_job::Variant::ResolveChildWorkflowExecution(_) => {
+                        write!(f, "ResolveChildWorkflowExecution")
+                    }
+                    workflow_activation_job::Variant::ResolveSignalExternalWorkflow(_) => {
+                        write!(f, "ResolveSignalExternalWorkflow")
+                    }
+                    workflow_activation_job::Variant::RemoveFromCache(_) => {
+                        write!(f, "RemoveFromCache")
+                    }
+                    workflow_activation_job::Variant::ResolveRequestCancelExternalWorkflow(_) => {
+                        write!(f, "ResolveRequestCancelExternalWorkflow")
+                    }
                 }
             }
         }
@@ -264,9 +533,10 @@ pub mod coresdk {
     }
 
     pub mod workflow_completion {
+        use crate::temporal::api::failure;
         tonic::include_proto!("coresdk.workflow_completion");
 
-        impl wf_activation_completion::Status {
+        impl workflow_activation_completion::Status {
             pub const fn is_success(&self) -> bool {
                 match &self {
                     Self::Successful(_) => true,
@@ -274,6 +544,12 @@ pub mod coresdk {
                 }
             }
         }
+
+        impl From<failure::v1::Failure> for Failure {
+            fn from(f: failure::v1::Failure) -> Self {
+                Failure { failure: Some(f) }
+            }
+        }
     }
 
     pub mod child_workflow {
@@ -290,51 +566,125 @@ pub mod coresdk {
             fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
                 match &self.variant {
                     None => write!(f, "Empty"),
-                    Some(v) => match v {
-                        workflow_command::Variant::StartTimer(_) => write!(f, "StartTimer"),
-                        workflow_command::Variant::ScheduleActivity(_) => {
-                            write!(f, "ScheduleActivity")
-                        }
-                        workflow_command::Variant::RespondToQuery(_) => write!(f, "RespondToQuery"),
-                        workflow_command::Variant::RequestCancelActivity(_) => {
-                            write!(f, "RequestCancelActivity")
-                        }
-                        workflow_command::Variant::CancelTimer(_) => write!(f, "CancelTimer"),
-                        workflow_command::Variant::CompleteWorkflowExecution(_) => {
-                            write!(f, "CompleteWorkflowExecution")
-                        }
-                        workflow_command::Variant::FailWorkflowExecution(_) => {
-                            write!(f, "FailWorkflowExecution")
-                        }
-                        workflow_command::Variant::ContinueAsNewWorkflowExecution(_) => {
-                            write!(f, "ContinueAsNewWorkflowExecution")
-                        }
-                        workflow_command::Variant::CancelWorkflowExecution(_) => {
-                            write!(f, "CancelWorkflowExecution")
-                        }
-                        workflow_command::Variant::SetPatchMarker(_) => {
-                            write!(f, "SetPatchMarker")
-                        }
-                        workflow_command::Variant::StartChildWorkflowExecution(_) => {
-                            write!(f, "StartChildWorkflowExecution")
-                        }
-                        workflow_command::Variant::RequestCancelExternalWorkflowExecution(_) => {
-                            write!(f, "RequestCancelExternalWorkflowExecution")
-                        }
-                        workflow_command::Variant::SignalExternalWorkflowExecution(_) => {
-                            write!(f, "SignalExternalWorkflowExecution")
-                        }
-                        workflow_command::Variant::CancelSignalWorkflow(_) => {
-                            write!(f, "CancelSignalWorkflow")
-                        }
-                        workflow_command::Variant::CancelUnstartedChildWorkflowExecution(_) => {
-                            write!(f, "CancelUnstartedChildWorkflowExecution")
-                        }
-                    },
+                    Some(v) => write!(f, "{}", v),
                 }
             }
         }
 
+        impl Display for StartTimer {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "StartTimer({})", self.seq)
+            }
+        }
+
+        impl Display for ScheduleActivity {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "ScheduleActivity({}, {})", self.seq, self.activity_type)
+            }
+        }
+
+        impl Display for ScheduleLocalActivity {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "ScheduleLocalActivity({}, {})",
+                    self.seq, self.activity_type
+                )
+            }
+        }
+
+        impl Display for QueryResult {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "RespondToQuery({})", self.query_id)
+            }
+        }
+
+        impl Display for RequestCancelActivity {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "RequestCancelActivity({})", self.seq)
+            }
+        }
+
+        impl Display for RequestCancelLocalActivity {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "RequestCancelLocalActivity({})", self.seq)
+            }
+        }
+
+        impl Display for CancelTimer {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "CancelTimer({})", self.seq)
+            }
+        }
+
+        impl Display for CompleteWorkflowExecution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "CompleteWorkflowExecution")
+            }
+        }
+
+        impl Display for FailWorkflowExecution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "FailWorkflowExecution")
+            }
+        }
+
+        impl Display for ContinueAsNewWorkflowExecution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "ContinueAsNewWorkflowExecution")
+            }
+        }
+
+        impl Display for CancelWorkflowExecution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "CancelWorkflowExecution")
+            }
+        }
+
+        impl Display for SetPatchMarker {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "SetPatchMarker({})", self.patch_id)
+            }
+        }
+
+        impl Display for StartChildWorkflowExecution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "StartChildWorkflowExecution({}, {})",
+                    self.seq, self.workflow_type
+                )
+            }
+        }
+
+        impl Display for RequestCancelExternalWorkflowExecution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "RequestCancelExternalWorkflowExecution({})", self.seq)
+            }
+        }
+
+        impl Display for SignalExternalWorkflowExecution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "SignalExternalWorkflowExecution({})", self.seq)
+            }
+        }
+
+        impl Display for CancelSignalWorkflow {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "CancelSignalWorkflow({})", self.seq)
+            }
+        }
+
+        impl Display for CancelUnstartedChildWorkflowExecution {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(
+                    f,
+                    "CancelUnstartedChildWorkflowExecution({})",
+                    self.child_workflow_seq
+                )
+            }
+        }
+
         impl QueryResult {
             /// Helper to construct the Temporal API query result types.
             pub fn into_components(self) -> (String, QueryResultType, Option<Payloads>, String) {
@@ -368,8 +718,8 @@ pub mod coresdk {
 
     pub type HistoryEventId = i64;
 
-    impl From<wf_activation_job::Variant> for WfActivationJob {
-        fn from(a: wf_activation_job::Variant) -> Self {
+    impl From<workflow_activation_job::Variant> for WorkflowActivationJob {
+        fn from(a: workflow_activation_job::Variant) -> Self {
             Self { variant: Some(a) }
         }
     }
@@ -396,14 +746,14 @@ pub mod coresdk {
         }
     }
 
-    impl WfActivationCompletion {
+    impl WorkflowActivationCompletion {
         /// Create a successful activation with no commands in it
         pub fn empty(task_queue: impl Into<String>, run_id: impl Into<String>) -> Self {
             let success = workflow_completion::Success::from_variants(vec![]);
             Self {
                 run_id: run_id.into(),
                 task_queue: task_queue.into(),
-                status: Some(wf_activation_completion::Status::Successful(success)),
+                status: Some(workflow_activation_completion::Status::Successful(success)),
             }
         }
 
@@ -417,7 +767,7 @@ pub mod coresdk {
             Self {
                 run_id: run_id.into(),
                 task_queue: task_q.into(),
-                status: Some(wf_activation_completion::Status::Successful(success)),
+                status: Some(workflow_activation_completion::Status::Successful(success)),
             }
         }
 
@@ -431,7 +781,7 @@ pub mod coresdk {
             Self {
                 run_id: run_id.into(),
                 task_queue: task_q.into(),
-                status: Some(wf_activation_completion::Status::Successful(success)),
+                status: Some(workflow_activation_completion::Status::Successful(success)),
             }
         }
 
@@ -443,7 +793,7 @@ pub mod coresdk {
             Self {
                 run_id: run_id.into(),
                 task_queue: task_q.into(),
-                status: Some(wf_activation_completion::Status::Failed(
+                status: Some(workflow_activation_completion::Status::Failed(
                     workflow_completion::Failure {
                         failure: Some(failure),
                     },
@@ -462,7 +812,7 @@ pub mod coresdk {
 
         /// Returns true if the activation contains a fail workflow execution command
         pub fn has_fail_execution(&self) -> bool {
-            if let Some(wf_activation_completion::Status::Successful(s)) = &self.status {
+            if let Some(workflow_activation_completion::Status::Successful(s)) = &self.status {
                 return s.commands.iter().any(|wfc| {
                     matches!(
                         wfc,
@@ -477,7 +827,7 @@ pub mod coresdk {
 
         /// Returns true if the activation contains a cancel workflow execution command
         pub fn has_cancel_workflow_execution(&self) -> bool {
-            if let Some(wf_activation_completion::Status::Successful(s)) = &self.status {
+            if let Some(workflow_activation_completion::Status::Successful(s)) = &self.status {
                 return s.commands.iter().any(|wfc| {
                     matches!(
                         wfc,
@@ -492,7 +842,7 @@ pub mod coresdk {
 
         /// Returns true if the activation contains a continue as new workflow execution command
         pub fn has_continue_as_new(&self) -> bool {
-            if let Some(wf_activation_completion::Status::Successful(s)) = &self.status {
+            if let Some(workflow_activation_completion::Status::Successful(s)) = &self.status {
                 return s.commands.iter().any(|wfc| {
                     matches!(
                         wfc,
@@ -509,7 +859,7 @@ pub mod coresdk {
 
         /// Returns true if the activation contains a complete workflow execution command
         pub fn has_complete_workflow_execution(&self) -> bool {
-            if let Some(wf_activation_completion::Status::Successful(s)) = &self.status {
+            if let Some(workflow_activation_completion::Status::Successful(s)) = &self.status {
                 return s.commands.iter().any(|wfc| {
                     matches!(
                         wfc,
@@ -523,15 +873,23 @@ pub mod coresdk {
         }
     }
 
-    /// Makes converting outgoing lang commands into [WfActivationCompletion]s easier
+    /// Makes converting outgoing lang commands into [WorkflowActivationCompletion]s easier
     pub trait IntoCompletion {
         /// The conversion function
-        fn into_completion(self, task_queue: String, run_id: String) -> WfActivationCompletion;
+        fn into_completion(
+            self,
+            task_queue: String,
+            run_id: String,
+        ) -> WorkflowActivationCompletion;
     }
 
     impl IntoCompletion for workflow_command::Variant {
-        fn into_completion(self, task_queue: String, run_id: String) -> WfActivationCompletion {
-            WfActivationCompletion::from_cmd(task_queue, run_id, self)
+        fn into_completion(
+            self,
+            task_queue: String,
+            run_id: String,
+        ) -> WorkflowActivationCompletion {
+            WorkflowActivationCompletion::from_cmd(task_queue, run_id, self)
         }
     }
 
@@ -540,21 +898,25 @@ pub mod coresdk {
         I: IntoIterator<Item = V>,
         V: Into<WorkflowCommand>,
     {
-        fn into_completion(self, task_queue: String, run_id: String) -> WfActivationCompletion {
+        fn into_completion(
+            self,
+            task_queue: String,
+            run_id: String,
+        ) -> WorkflowActivationCompletion {
             let success = self.into_iter().map(Into::into).collect::<Vec<_>>().into();
-            WfActivationCompletion {
+            WorkflowActivationCompletion {
                 run_id,
                 task_queue,
-                status: Some(wf_activation_completion::Status::Successful(success)),
+                status: Some(workflow_activation_completion::Status::Successful(success)),
             }
         }
     }
 
-    impl Display for WfActivationCompletion {
+    impl Display for WorkflowActivationCompletion {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
             write!(
                 f,
-                "WfActivationCompletion(run_id: {}, status: ",
+                "WorkflowActivationCompletion(run_id: {}, status: ",
                 &self.run_id
             )?;
             match &self.status {
@@ -565,12 +927,12 @@ pub mod coresdk {
         }
     }
 
-    impl Display for wf_activation_completion::Status {
+    impl Display for workflow_activation_completion::Status {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
             match self {
-                wf_activation_completion::Status::Successful(workflow_completion::Success {
-                    commands,
-                }) => {
+                workflow_activation_completion::Status::Successful(
+                    workflow_completion::Success { commands },
+                ) => {
                     write!(f, "Success(")?;
                     let mut written = 0;
                     for c in commands {
@@ -583,32 +945,13 @@ pub mod coresdk {
                     }
                     write!(f, ")")
                 }
-                wf_activation_completion::Status::Failed(_) => {
+                workflow_activation_completion::Status::Failed(_) => {
                     write!(f, "Failed")
                 }
             }
         }
     }
 
-    impl ActivityResult {
-        pub const fn ok(result: Payload) -> Self {
-            Self {
-                status: Some(activity_result::activity_result::Status::Completed(
-                    activity_result::Success {
-                        result: Some(result),
-                    },
-                )),
-            }
-        }
-
-        pub fn unwrap_ok_payload(self) -> Payload {
-            match self.status.unwrap() {
-                activity_result::activity_result::Status::Completed(c) => c.result.unwrap(),
-                _ => panic!("Activity was not successful"),
-            }
-        }
-    }
-
     impl ActivityTask {
         pub fn start_from_poll_resp(r: PollActivityTaskQueueResponse) -> Self {
             let (workflow_id, run_id) = r
@@ -617,7 +960,6 @@ pub mod coresdk {
                 .unwrap_or_default();
             Self {
                 task_token: r.task_token,
-                activity_id: r.activity_id,
                 variant: Some(activity_task::activity_task::Variant::Start(
                     activity_task::Start {
                         workflow_namespace: r.workflow_namespace,
@@ -626,6 +968,7 @@ pub mod coresdk {
                             workflow_id,
                             run_id,
                         }),
+                        activity_id: r.activity_id,
                         activity_type: r.activity_type.map_or_else(|| "".to_string(), |at| at.name),
                         header_fields: r.header.map(Into::into).unwrap_or_default(),
                         input: Vec::from_payloads(r.input),
@@ -633,11 +976,12 @@ pub mod coresdk {
                         scheduled_time: r.scheduled_time,
                         current_attempt_scheduled_time: r.current_attempt_scheduled_time,
                         started_time: r.started_time,
-                        attempt: r.attempt,
+                        attempt: r.attempt as u32,
                         schedule_to_close_timeout: r.schedule_to_close_timeout,
                         start_to_close_timeout: r.start_to_close_timeout,
                         heartbeat_timeout: r.heartbeat_timeout,
                         retry_policy: r.retry_policy.map(Into::into),
+                        is_local: false,
                     },
                 )),
             }
@@ -666,6 +1010,10 @@ pub mod coresdk {
     }
 
     impl Failure {
+        pub fn is_timeout(&self) -> bool {
+            matches!(self.failure_info, Some(FailureInfo::TimeoutFailureInfo(_)))
+        }
+
         pub fn application_failure(message: String, non_retryable: bool) -> Self {
             Self {
                 message,
@@ -680,6 +1028,18 @@ pub mod coresdk {
         }
     }
 
+    impl From<&str> for Failure {
+        fn from(v: &str) -> Self {
+            Failure::application_failure(v.to_string(), false)
+        }
+    }
+
+    impl From<anyhow::Error> for Failure {
+        fn from(ae: anyhow::Error) -> Self {
+            Failure::application_failure(ae.to_string(), false)
+        }
+    }
+
     impl From<common::Payload> for super::temporal::api::common::v1::Payload {
         fn from(p: Payload) -> Self {
             Self {
@@ -767,6 +1127,55 @@ pub mod coresdk {
         }
     }
 
+    #[derive(thiserror::Error, Debug)]
+    pub enum PayloadDeserializeErr {
+        /// This deserializer does not handle this type of payload. Allows composing multiple
+        /// deserializers.
+        #[error("This deserializer does not understand this payload")]
+        DeserializerDoesNotHandle,
+        #[error("Error during deserialization: {0}")]
+        DeserializeErr(#[from] anyhow::Error),
+    }
+
+    // TODO: Once the prototype SDK is un-prototyped this serialization will need to be compat with
+    //   other SDKs (given they might execute an activity).
+    pub trait AsJsonPayloadExt {
+        fn as_json_payload(&self) -> anyhow::Result<Payload>;
+    }
+    impl<T> AsJsonPayloadExt for T
+    where
+        T: Serialize,
+    {
+        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());
+            Ok(Payload {
+                metadata,
+                data: as_json.into_bytes(),
+            })
+        }
+    }
+
+    pub trait FromJsonPayloadExt: Sized {
+        fn from_json_payload(payload: &Payload) -> Result<Self, PayloadDeserializeErr>;
+    }
+    impl<T> FromJsonPayloadExt for T
+    where
+        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")
+            ) {
+                return Err(PayloadDeserializeErr::DeserializerDoesNotHandle);
+            }
+            let payload_str = std::str::from_utf8(&payload.data).map_err(anyhow::Error::from)?;
+            Ok(serde_json::from_str(payload_str).map_err(anyhow::Error::from)?)
+        }
+    }
+
     /// Errors when converting from a [Payloads] api proto to our internal [common::Payload]
     #[derive(derive_more::Display, Debug)]
     pub enum PayloadsToPayloadError {
@@ -792,8 +1201,12 @@ pub mod coresdk {
 }
 
 // No need to lint these
-#[allow(clippy::all)]
-#[allow(missing_docs)]
+#[allow(
+    clippy::all,
+    missing_docs,
+    rustdoc::broken_intra_doc_links,
+    rustdoc::bare_urls
+)]
 // This is disgusting, but unclear to me how to avoid it. TODO: Discuss w/ prost maintainer
 pub mod temporal {
     pub mod api {
@@ -1077,11 +1490,31 @@ pub mod temporal {
                 use crate::temporal::api::{
                     enums::v1::EventType, history::v1::history_event::Attributes,
                 };
+                use anyhow::bail;
                 use prost::alloc::fmt::Formatter;
                 use std::fmt::Display;
 
                 tonic::include_proto!("temporal.api.history.v1");
 
+                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?!?")
+                        }
+                    }
+
+                    /// Returns the event id of the final event in the history. Will return 0 if
+                    /// there are no events.
+                    pub fn last_event_id(&self) -> i64 {
+                        self.events.last().map(|e| e.event_id).unwrap_or_default()
+                    }
+                }
+
                 impl HistoryEvent {
                     /// Returns true if this is an event created to mirror a command
                     pub fn is_command_event(&self) -> bool {