@temporalio/core-bridge 1.11.6 → 1.11.8

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

@@ -13,8 +13,8 @@ mod task_token;
 
 #[cfg(feature = "history_builders")]
 pub use history_builder::{
-    default_act_sched, default_wes_attribs, TestHistoryBuilder, DEFAULT_ACTIVITY_TYPE,
-    DEFAULT_WORKFLOW_TYPE,
+    DEFAULT_ACTIVITY_TYPE, DEFAULT_WORKFLOW_TYPE, TestHistoryBuilder, default_act_sched,
+    default_wes_attribs,
 };
 #[cfg(feature = "history_builders")]
 pub use history_info::HistoryInfo;
@@ -37,13 +37,16 @@ pub mod coresdk {
     tonic::include_proto!("coresdk");
 
     use crate::{
+        ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL,
         temporal::api::{
             common::v1::{Payload, Payloads, WorkflowExecution},
-            enums::v1::WorkflowTaskFailedCause,
-            failure::v1::{failure::FailureInfo, ApplicationFailureInfo, Failure},
+            enums::v1::{TimeoutType, WorkflowTaskFailedCause},
+            failure::v1::{
+                ActivityFailureInfo, ApplicationFailureInfo, Failure, TimeoutFailureInfo,
+                failure::FailureInfo,
+            },
             workflowservice::v1::PollActivityTaskQueueResponse,
         },
-        ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL,
     };
     use activity_task::ActivityTask;
     use serde::{Deserialize, Serialize};
@@ -53,9 +56,9 @@ pub mod coresdk {
         fmt::{Display, Formatter},
         iter::FromIterator,
     };
-    use workflow_activation::{workflow_activation_job, WorkflowActivationJob};
-    use workflow_commands::{workflow_command, workflow_command::Variant, WorkflowCommand};
-    use workflow_completion::{workflow_activation_completion, WorkflowActivationCompletion};
+    use workflow_activation::{WorkflowActivationJob, workflow_activation_job};
+    use workflow_commands::{WorkflowCommand, workflow_command, workflow_command::Variant};
+    use workflow_completion::{WorkflowActivationCompletion, workflow_activation_completion};
 
     #[allow(clippy::module_inception)]
     pub mod activity_task {
@@ -104,7 +107,7 @@ pub mod coresdk {
         tonic::include_proto!("coresdk.activity_result");
         use super::super::temporal::api::{
             common::v1::Payload,
-            failure::v1::{failure, CanceledFailureInfo, Failure as APIFailure},
+            failure::v1::{CanceledFailureInfo, Failure as APIFailure, failure},
         };
         use crate::{
             coresdk::activity_result::activity_resolution::Status,
@@ -284,12 +287,12 @@ pub mod coresdk {
         tonic::include_proto!("coresdk.common");
         use super::external_data::LocalActivityMarkerData;
         use crate::{
+            PATCHED_MARKER_DETAILS_KEY,
             coresdk::{
-                external_data::PatchedMarkerData, AsJsonPayloadExt, FromJsonPayloadExt,
-                IntoPayloadsExt,
+                AsJsonPayloadExt, FromJsonPayloadExt, IntoPayloadsExt,
+                external_data::PatchedMarkerData,
             },
             temporal::api::common::v1::{Payload, Payloads},
-            PATCHED_MARKER_DETAILS_KEY,
         };
         use std::collections::HashMap;
 
@@ -447,10 +450,10 @@ pub mod coresdk {
     pub mod workflow_activation {
         use crate::{
             coresdk::{
-                activity_result::{activity_resolution, ActivityResolution},
+                FromPayloadsExt,
+                activity_result::{ActivityResolution, activity_resolution},
                 common::NamespacedWorkflowExecution,
                 workflow_activation::remove_from_cache::EvictionReason,
-                FromPayloadsExt,
             },
             temporal::api::{
                 enums::v1::WorkflowTaskFailedCause,
@@ -602,7 +605,7 @@ pub mod coresdk {
                             r.seq,
                             r.result
                                 .as_ref()
-                                .unwrap_or_else(|| &ActivityResolution { status: None })
+                                .unwrap_or(&ActivityResolution { status: None })
                         )
                     }
                     workflow_activation_job::Variant::NotifyHasPatch(_) => {
@@ -626,6 +629,12 @@ pub mod coresdk {
                     workflow_activation_job::Variant::DoUpdate(_) => {
                         write!(f, "DoUpdate")
                     }
+                    workflow_activation_job::Variant::ResolveNexusOperationStart(_) => {
+                        write!(f, "ResolveNexusOperationStart")
+                    }
+                    workflow_activation_job::Variant::ResolveNexusOperation(_) => {
+                        write!(f, "ResolveNexusOperation")
+                    }
                 }
             }
         }
@@ -674,8 +683,8 @@ pub mod coresdk {
         }
 
         impl From<WorkflowExecutionCancelRequestedEventAttributes> for CancelWorkflow {
-            fn from(_a: WorkflowExecutionCancelRequestedEventAttributes) -> Self {
-                Self { details: vec![] }
+            fn from(a: WorkflowExecutionCancelRequestedEventAttributes) -> Self {
+                Self { reason: a.cause }
             }
         }
 
@@ -716,6 +725,7 @@ pub mod coresdk {
                 memo: attrs.memo,
                 search_attributes: attrs.search_attributes,
                 start_time: Some(start_time),
+                root_workflow: attrs.root_workflow_execution,
             }
         }
     }
@@ -747,6 +757,50 @@ pub mod coresdk {
         tonic::include_proto!("coresdk.child_workflow");
     }
 
+    pub mod nexus {
+        use crate::temporal::api::workflowservice::v1::PollNexusTaskQueueResponse;
+        use std::fmt::{Display, Formatter};
+
+        tonic::include_proto!("coresdk.nexus");
+
+        impl NexusTask {
+            /// Unwrap the inner server-delivered nexus task if that's what this is, else panic.
+            pub fn unwrap_task(self) -> PollNexusTaskQueueResponse {
+                if let Some(nexus_task::Variant::Task(t)) = self.variant {
+                    return t;
+                }
+                panic!("Nexus task did not contain a server task");
+            }
+
+            /// Get the task token
+            pub fn task_token(&self) -> &[u8] {
+                match &self.variant {
+                    Some(nexus_task::Variant::Task(t)) => t.task_token.as_slice(),
+                    Some(nexus_task::Variant::CancelTask(c)) => c.task_token.as_slice(),
+                    None => panic!("Nexus task did not contain a task token"),
+                }
+            }
+        }
+
+        impl Display for nexus_task_completion::Status {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "NexusTaskCompletion(")?;
+                match self {
+                    nexus_task_completion::Status::Completed(c) => {
+                        write!(f, "{c}")
+                    }
+                    nexus_task_completion::Status::Error(e) => {
+                        write!(f, "{e}")
+                    }
+                    nexus_task_completion::Status::AckCancel(_) => {
+                        write!(f, "AckCancel")
+                    }
+                }?;
+                write!(f, ")")
+            }
+        }
+    }
+
     pub mod workflow_commands {
         tonic::include_proto!("coresdk.workflow_commands");
 
@@ -906,6 +960,18 @@ pub mod coresdk {
             }
         }
 
+        impl Display for ScheduleNexusOperation {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "ScheduleNexusOperation({})", self.seq)
+            }
+        }
+
+        impl Display for RequestCancelNexusOperation {
+            fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                write!(f, "RequestCancelNexusOperation({})", self.seq)
+            }
+        }
+
         impl QueryResult {
             /// Helper to construct the Temporal API query result types.
             pub fn into_components(self) -> (String, QueryResultType, Option<Payloads>, String) {
@@ -956,16 +1022,16 @@ pub mod coresdk {
 
     impl From<workflow_command::Variant> for WorkflowCommand {
         fn from(v: workflow_command::Variant) -> Self {
-            Self { variant: Some(v) }
+            Self {
+                variant: Some(v),
+                user_metadata: None,
+            }
         }
     }
 
     impl workflow_completion::Success {
         pub fn from_variants(cmds: Vec<Variant>) -> Self {
-            let cmds: Vec<_> = cmds
-                .into_iter()
-                .map(|c| WorkflowCommand { variant: Some(c) })
-                .collect();
+            let cmds: Vec<_> = cmds.into_iter().map(|c| c.into()).collect();
             cmds.into()
         }
     }
@@ -980,7 +1046,7 @@ pub mod coresdk {
             }
         }
 
-        /// Create a successful activation from a list of commands
+        /// Create a successful activation from a list of command variants
         pub fn from_cmds(run_id: impl Into<String>, cmds: Vec<workflow_command::Variant>) -> Self {
             let success = workflow_completion::Success::from_variants(cmds);
             Self {
@@ -989,7 +1055,7 @@ pub mod coresdk {
             }
         }
 
-        /// Create a successful activation from just one command
+        /// Create a successful activation from just one command variant
         pub fn from_cmd(run_id: impl Into<String>, cmd: workflow_command::Variant) -> Self {
             let success = workflow_completion::Success::from_variants(vec![cmd]);
             Self {
@@ -1031,6 +1097,7 @@ pub mod coresdk {
                         wfc,
                         WorkflowCommand {
                             variant: Some(workflow_command::Variant::FailWorkflowExecution(_)),
+                            ..
                         }
                     )
                 });
@@ -1046,6 +1113,7 @@ pub mod coresdk {
                         wfc,
                         WorkflowCommand {
                             variant: Some(workflow_command::Variant::CancelWorkflowExecution(_)),
+                            ..
                         }
                     )
                 });
@@ -1063,6 +1131,7 @@ pub mod coresdk {
                             variant: Some(
                                 workflow_command::Variant::ContinueAsNewWorkflowExecution(_)
                             ),
+                            ..
                         }
                     )
                 });
@@ -1078,7 +1147,8 @@ pub mod coresdk {
                         wfc,
                         WorkflowCommand {
                             variant: Some(workflow_command::Variant::CompleteWorkflowExecution(_)),
-                        }
+                            ..
+                        },
                     )
                 });
             }
@@ -1194,7 +1264,7 @@ pub mod coresdk {
                         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),
+                        retry_policy: r.retry_policy,
                         is_local: false,
                     },
                 )),
@@ -1243,6 +1313,24 @@ pub mod coresdk {
             }
         }
 
+        pub fn timeout(timeout_type: TimeoutType) -> Self {
+            Self {
+                message: "Activity timed out".to_string(),
+                cause: Some(Box::new(Failure {
+                    message: "Activity timed out".to_string(),
+                    failure_info: Some(FailureInfo::TimeoutFailureInfo(TimeoutFailureInfo {
+                        timeout_type: timeout_type.into(),
+                        ..Default::default()
+                    })),
+                    ..Default::default()
+                })),
+                failure_info: Some(FailureInfo::ActivityFailureInfo(
+                    ActivityFailureInfo::default(),
+                )),
+                ..Default::default()
+            }
+        }
+
         /// Extracts an ApplicationFailureInfo from a Failure instance if it exists
         pub fn maybe_application_failure(&self) -> Option<&ApplicationFailureInfo> {
             if let Failure {
@@ -1301,6 +1389,9 @@ pub mod coresdk {
                         v.scheduled_event_id
                     )?;
                 }
+                Some(FailureInfo::NexusHandlerFailureInfo(v)) => {
+                    write!(f, "Nexus Handler Failure: {}", v.r#type)?;
+                }
             }
             write!(f, ")")
         }
@@ -1334,7 +1425,7 @@ pub mod coresdk {
         fn from_payloads(p: Option<Payloads>) -> Self {
             match p {
                 None => std::iter::empty().collect(),
-                Some(p) => p.payloads.into_iter().map(Into::into).collect(),
+                Some(p) => p.payloads.into_iter().collect(),
             }
         }
     }
@@ -1352,7 +1443,7 @@ pub mod coresdk {
                 None
             } else {
                 Some(Payloads {
-                    payloads: iterd.map(Into::into).collect(),
+                    payloads: iterd.collect(),
                 })
             }
         }
@@ -1473,7 +1564,7 @@ pub mod temporal {
                 tonic::include_proto!("temporal.api.command.v1");
 
                 use crate::{
-                    coresdk::{workflow_commands, IntoPayloadsExt},
+                    coresdk::{IntoPayloadsExt, workflow_commands},
                     temporal::api::{
                         common::v1::{ActivityType, WorkflowType},
                         enums::v1::CommandType,
@@ -1538,6 +1629,13 @@ pub mod temporal {
                                 attributes: Some(a),
                                 user_metadata: Default::default(),
                             },
+                            a @ Attributes::RequestCancelNexusOperationCommandAttributes(_) => {
+                                Self {
+                                    command_type: CommandType::RequestCancelNexusOperation as i32,
+                                    attributes: Some(a),
+                                    user_metadata: Default::default(),
+                                }
+                            }
                             _ => unimplemented!(),
                         }
                     }
@@ -1551,6 +1649,70 @@ pub mod temporal {
                     }
                 }
 
+                pub trait CommandAttributesExt {
+                    fn as_type(&self) -> CommandType;
+                }
+
+                impl CommandAttributesExt for command::Attributes {
+                    fn as_type(&self) -> CommandType {
+                        match self {
+                            Attributes::ScheduleActivityTaskCommandAttributes(_) => {
+                                CommandType::ScheduleActivityTask
+                            }
+                            Attributes::StartTimerCommandAttributes(_) => CommandType::StartTimer,
+                            Attributes::CompleteWorkflowExecutionCommandAttributes(_) => {
+                                CommandType::CompleteWorkflowExecution
+                            }
+                            Attributes::FailWorkflowExecutionCommandAttributes(_) => {
+                                CommandType::FailWorkflowExecution
+                            }
+                            Attributes::RequestCancelActivityTaskCommandAttributes(_) => {
+                                CommandType::RequestCancelActivityTask
+                            }
+                            Attributes::CancelTimerCommandAttributes(_) => CommandType::CancelTimer,
+                            Attributes::CancelWorkflowExecutionCommandAttributes(_) => {
+                                CommandType::CancelWorkflowExecution
+                            }
+                            Attributes::RequestCancelExternalWorkflowExecutionCommandAttributes(
+                                _,
+                            ) => CommandType::RequestCancelExternalWorkflowExecution,
+                            Attributes::RecordMarkerCommandAttributes(_) => {
+                                CommandType::RecordMarker
+                            }
+                            Attributes::ContinueAsNewWorkflowExecutionCommandAttributes(_) => {
+                                CommandType::ContinueAsNewWorkflowExecution
+                            }
+                            Attributes::StartChildWorkflowExecutionCommandAttributes(_) => {
+                                CommandType::StartChildWorkflowExecution
+                            }
+                            Attributes::SignalExternalWorkflowExecutionCommandAttributes(_) => {
+                                CommandType::SignalExternalWorkflowExecution
+                            }
+                            Attributes::UpsertWorkflowSearchAttributesCommandAttributes(_) => {
+                                CommandType::UpsertWorkflowSearchAttributes
+                            }
+                            Attributes::ProtocolMessageCommandAttributes(_) => {
+                                CommandType::ProtocolMessage
+                            }
+                            Attributes::ModifyWorkflowPropertiesCommandAttributes(_) => {
+                                CommandType::ModifyWorkflowProperties
+                            }
+                            Attributes::ScheduleNexusOperationCommandAttributes(_) => {
+                                CommandType::ScheduleNexusOperation
+                            }
+                            Attributes::RequestCancelNexusOperationCommandAttributes(_) => {
+                                CommandType::RequestCancelNexusOperation
+                            }
+                        }
+                    }
+                }
+
+                impl Display for command::Attributes {
+                    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                        write!(f, "{:?}", self.as_type())
+                    }
+                }
+
                 impl From<workflow_commands::StartTimer> for command::Attributes {
                     fn from(s: workflow_commands::StartTimer) -> Self {
                         Self::StartTimerCommandAttributes(StartTimerCommandAttributes {
@@ -1608,6 +1770,7 @@ pub mod temporal {
                             retry_policy: s.retry_policy.map(Into::into),
                             request_eager_execution: !s.do_not_eagerly_execute,
                             use_workflow_build_id,
+                            priority: s.priority,
                         },
                     )
                 }
@@ -1637,6 +1800,7 @@ pub mod temporal {
                             cron_schedule: s.cron_schedule.clone(),
                             parent_close_policy: s.parent_close_policy,
                             inherit_build_id,
+                            priority: s.priority,
                         },
                     )
                 }
@@ -1701,9 +1865,29 @@ pub mod temporal {
                         )
                     }
                 }
+
+                impl From<workflow_commands::ScheduleNexusOperation> for command::Attributes {
+                    fn from(c: workflow_commands::ScheduleNexusOperation) -> Self {
+                        Self::ScheduleNexusOperationCommandAttributes(
+                            ScheduleNexusOperationCommandAttributes {
+                                endpoint: c.endpoint,
+                                service: c.service,
+                                operation: c.operation,
+                                input: c.input,
+                                schedule_to_close_timeout: c.schedule_to_close_timeout,
+                                nexus_header: c.nexus_header,
+                            },
+                        )
+                    }
+                }
             }
         }
         pub mod cloud {
+            pub mod account {
+                pub mod v1 {
+                    tonic::include_proto!("temporal.api.cloud.account.v1");
+                }
+            }
             pub mod cloudservice {
                 pub mod v1 {
                     tonic::include_proto!("temporal.api.cloud.cloudservice.v1");
@@ -1719,6 +1903,11 @@ pub mod temporal {
                     tonic::include_proto!("temporal.api.cloud.namespace.v1");
                 }
             }
+            pub mod nexus {
+                pub mod v1 {
+                    tonic::include_proto!("temporal.api.cloud.nexus.v1");
+                }
+            }
             pub mod operation {
                 pub mod v1 {
                     tonic::include_proto!("temporal.api.cloud.operation.v1");
@@ -1729,11 +1918,26 @@ pub mod temporal {
                     tonic::include_proto!("temporal.api.cloud.region.v1");
                 }
             }
+            pub mod resource {
+                pub mod v1 {
+                    tonic::include_proto!("temporal.api.cloud.resource.v1");
+                }
+            }
+            pub mod sink {
+                pub mod v1 {
+                    tonic::include_proto!("temporal.api.cloud.sink.v1");
+                }
+            }
+            pub mod usage {
+                pub mod v1 {
+                    tonic::include_proto!("temporal.api.cloud.usage.v1");
+                }
+            }
         }
         pub mod common {
             pub mod v1 {
                 use crate::{ENCODING_PAYLOAD_KEY, JSON_ENCODING_VAL};
-                use base64::{prelude::BASE64_STANDARD, Engine};
+                use base64::{Engine, prelude::BASE64_STANDARD};
                 use std::{
                     collections::HashMap,
                     fmt::{Display, Formatter},
@@ -1863,6 +2067,11 @@ pub mod temporal {
                 }
             }
         }
+        pub mod deployment {
+            pub mod v1 {
+                tonic::include_proto!("temporal.api.deployment.v1");
+            }
+        }
         pub mod enums {
             pub mod v1 {
                 tonic::include_proto!("temporal.api.enums.v1");
@@ -1927,6 +2136,8 @@ pub mod temporal {
                             | EventType::TimerStarted
                             | EventType::UpsertWorkflowSearchAttributes
                             | EventType::WorkflowPropertiesModified
+                            | EventType::NexusOperationScheduled
+                            | EventType::NexusOperationCancelRequested
                             | EventType::WorkflowExecutionCanceled
                             | EventType::WorkflowExecutionCompleted
                             | EventType::WorkflowExecutionContinuedAsNew
@@ -1971,6 +2182,12 @@ pub mod temporal {
                                 Attributes::WorkflowTaskCompletedEventAttributes(a) => Some(a.scheduled_event_id),
                                 Attributes::WorkflowTaskTimedOutEventAttributes(a) => Some(a.scheduled_event_id),
                                 Attributes::WorkflowTaskFailedEventAttributes(a) => Some(a.scheduled_event_id),
+                                Attributes::NexusOperationStartedEventAttributes(a) => Some(a.scheduled_event_id),
+                                Attributes::NexusOperationCompletedEventAttributes(a) => Some(a.scheduled_event_id),
+                                Attributes::NexusOperationFailedEventAttributes(a) => Some(a.scheduled_event_id),
+                                Attributes::NexusOperationTimedOutEventAttributes(a) => Some(a.scheduled_event_id),
+                                Attributes::NexusOperationCanceledEventAttributes(a) => Some(a.scheduled_event_id),
+                                Attributes::NexusOperationCancelRequestedEventAttributes(a) => Some(a.scheduled_event_id),
                                 _ => None
                             }
                         })
@@ -2078,6 +2295,7 @@ pub mod temporal {
                             Attributes::NexusOperationCanceledEventAttributes(_) => { EventType::NexusOperationCanceled }
                             Attributes::NexusOperationTimedOutEventAttributes(_) => { EventType::NexusOperationTimedOut }
                             Attributes::NexusOperationCancelRequestedEventAttributes(_) => { EventType::NexusOperationCancelRequested }
+                            Attributes::WorkflowExecutionOptionsUpdatedEventAttributes(_) => { EventType::WorkflowExecutionOptionsUpdated }
                         }
                     }
                 }
@@ -2174,7 +2392,123 @@ pub mod temporal {
         }
         pub mod nexus {
             pub mod v1 {
+                use crate::temporal::api::{
+                    common,
+                    common::v1::link::{WorkflowEvent, workflow_event},
+                    enums::v1::EventType,
+                };
+                use anyhow::{anyhow, bail};
+                use std::fmt::{Display, Formatter};
+                use tonic::transport::Uri;
+
                 tonic::include_proto!("temporal.api.nexus.v1");
+
+                impl Display for Response {
+                    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                        write!(f, "NexusResponse(",)?;
+                        match &self.variant {
+                            None => {}
+                            Some(v) => {
+                                write!(f, "{v}")?;
+                            }
+                        }
+                        write!(f, ")")
+                    }
+                }
+
+                impl Display for response::Variant {
+                    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                        match self {
+                            response::Variant::StartOperation(_) => {
+                                write!(f, "StartOperation")
+                            }
+                            response::Variant::CancelOperation(_) => {
+                                write!(f, "CancelOperation")
+                            }
+                        }
+                    }
+                }
+
+                impl Display for HandlerError {
+                    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+                        write!(f, "HandlerError")
+                    }
+                }
+
+                static SCHEME_PREFIX: &str = "temporal://";
+
+                /// Attempt to parse a nexus lint into a workflow event link
+                pub fn workflow_event_link_from_nexus(
+                    l: &Link,
+                ) -> Result<common::v1::Link, anyhow::Error> {
+                    if !l.url.starts_with(SCHEME_PREFIX) {
+                        bail!("Invalid scheme for nexus link: {:?}", l.url);
+                    }
+                    // We strip the scheme/authority portion because of
+                    // https://github.com/hyperium/http/issues/696
+                    let no_authority_url = l.url.strip_prefix(SCHEME_PREFIX).unwrap();
+                    let uri = Uri::try_from(no_authority_url)?;
+                    let parts = uri.into_parts();
+                    let path = parts.path_and_query.ok_or_else(|| {
+                        anyhow!("Failed to parse nexus link, invalid path: {:?}", l)
+                    })?;
+                    let path_parts = path.path().split('/').collect::<Vec<_>>();
+                    if path_parts.get(1) != Some(&"namespaces") {
+                        bail!("Invalid path for nexus link: {:?}", l);
+                    }
+                    let namespace = path_parts.get(2).ok_or_else(|| {
+                        anyhow!("Failed to parse nexus link, no namespace: {:?}", l)
+                    })?;
+                    if path_parts.get(3) != Some(&"workflows") {
+                        bail!("Invalid path for nexus link, no workflows segment: {:?}", l);
+                    }
+                    let workflow_id = path_parts.get(4).ok_or_else(|| {
+                        anyhow!("Failed to parse nexus link, no workflow id: {:?}", l)
+                    })?;
+                    let run_id = path_parts
+                        .get(5)
+                        .ok_or_else(|| anyhow!("Failed to parse nexus link, no run id: {:?}", l))?;
+                    if path_parts.get(6) != Some(&"history") {
+                        bail!("Invalid path for nexus link, no history segment: {:?}", l);
+                    }
+                    let reference = if let Some(query) = path.query() {
+                        let mut eventref = workflow_event::EventReference::default();
+                        let query_parts = query.split('&').collect::<Vec<_>>();
+                        for qp in query_parts {
+                            let mut kv = qp.split('=');
+                            let key = kv.next().ok_or_else(|| {
+                                anyhow!("Failed to parse nexus link query parameter: {:?}", l)
+                            })?;
+                            let val = kv.next().ok_or_else(|| {
+                                anyhow!("Failed to parse nexus link query parameter: {:?}", l)
+                            })?;
+                            match key {
+                                "eventID" => {
+                                    eventref.event_id = val.parse().map_err(|_| {
+                                        anyhow!("Failed to parse nexus link event id: {:?}", l)
+                                    })?;
+                                }
+                                "eventType" => {
+                                    eventref.event_type =
+                                        EventType::from_str_name(val).unwrap_or_default().into()
+                                }
+                                _ => continue,
+                            }
+                        }
+                        Some(workflow_event::Reference::EventRef(eventref))
+                    } else {
+                        None
+                    };
+
+                    Ok(common::v1::Link {
+                        variant: Some(common::v1::link::Variant::WorkflowEvent(WorkflowEvent {
+                            namespace: namespace.to_string(),
+                            workflow_id: workflow_id.to_string(),
+                            run_id: run_id.to_string(),
+                            reference,
+                        })),
+                    })
+                }
             }
         }
         pub mod workflowservice {
@@ -2195,10 +2529,8 @@ pub mod temporal {
                             if let Some((sch, st)) =
                                 self.$sched_field.clone().zip(self.started_time.clone())
                             {
-                                let sch: Result<SystemTime, _> = sch.try_into();
-                                let st: Result<SystemTime, _> = st.try_into();
-                                if let (Ok(sch), Ok(st)) = (sch, st) {
-                                    return st.duration_since(sch).ok();
+                                if let Some(value) = elapsed_between_prost_times(sch, st) {
+                                    return value;
                                 }
                             }
                             None
@@ -2206,6 +2538,18 @@ pub mod temporal {
                     };
                 }
 
+                fn elapsed_between_prost_times(
+                    from: prost_wkt_types::Timestamp,
+                    to: prost_wkt_types::Timestamp,
+                ) -> Option<Option<Duration>> {
+                    let from: Result<SystemTime, _> = from.try_into();
+                    let to: Result<SystemTime, _> = to.try_into();
+                    if let (Ok(from), Ok(to)) = (from, to) {
+                        return Some(to.duration_since(from).ok());
+                    }
+                    None
+                }
+
                 impl PollWorkflowTaskQueueResponse {
                     sched_to_start_impl!(scheduled_time);
                 }
@@ -2252,6 +2596,23 @@ pub mod temporal {
                     sched_to_start_impl!(current_attempt_scheduled_time);
                 }
 
+                impl PollNexusTaskQueueResponse {
+                    pub fn sched_to_start(&self) -> Option<Duration> {
+                        if let Some((sch, st)) = self
+                            .request
+                            .as_ref()
+                            .and_then(|r| r.scheduled_time)
+                            .clone()
+                            .zip(SystemTime::now().try_into().ok())
+                        {
+                            if let Some(value) = elapsed_between_prost_times(sch, st) {
+                                return value;
+                            }
+                        }
+                        None
+                    }
+                }
+
                 impl QueryWorkflowResponse {
                     /// Unwrap a successful response as vec of payloads
                     pub fn unwrap(self) -> Vec<crate::temporal::api::common::v1::Payload> {
@@ -2277,6 +2638,25 @@ pub mod grpc {
     }
 }
 
+/// Case conversion, used for json -> proto enum string conversion
+pub fn camel_case_to_screaming_snake(val: &str) -> String {
+    let mut out = String::new();
+    let mut last_was_upper = true;
+    for c in val.chars() {
+        if c.is_uppercase() {
+            if !last_was_upper {
+                out.push('_');
+            }
+            out.push(c.to_ascii_uppercase());
+            last_was_upper = true;
+        } else {
+            out.push(c.to_ascii_uppercase());
+            last_was_upper = false;
+        }
+    }
+    out
+}
+
 #[cfg(test)]
 mod tests {
     use crate::temporal::api::failure::v1::Failure;