@temporalio/core-bridge 1.5.2 → 1.6.0

package/sdk-core/protos/api_upstream/temporal/api/version/v1/message.proto

@@ -28,8 +28,8 @@ option go_package = "go.temporal.io/api/version/v1;version";
 option java_package = "io.temporal.api.version.v1";
 option java_multiple_files = true;
 option java_outer_classname = "MessageProto";
-option ruby_package = "Temporal::Api::Version::V1";
-option csharp_namespace = "Temporal.Api.Version.V1";
+option ruby_package = "Temporalio::Api::Version::V1";
+option csharp_namespace = "Temporalio.Api.Version.V1";
 
 import "google/protobuf/timestamp.proto";
 import "dependencies/gogoproto/gogo.proto";

package/sdk-core/protos/api_upstream/temporal/api/workflow/v1/message.proto

@@ -28,8 +28,8 @@ option go_package = "go.temporal.io/api/workflow/v1;workflow";
 option java_package = "io.temporal.api.workflow.v1";
 option java_multiple_files = true;
 option java_outer_classname = "MessageProto";
-option ruby_package = "Temporal::Api::Workflow::V1";
-option csharp_namespace = "Temporal.Api.Workflow.V1";
+option ruby_package = "Temporalio::Api::Workflow::V1";
+option csharp_namespace = "Temporalio.Api.Workflow.V1";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";

package/sdk-core/protos/api_upstream/temporal/api/workflowservice/v1/request_response.proto

@@ -28,8 +28,8 @@ option go_package = "go.temporal.io/api/workflowservice/v1;workflowservice";
 option java_package = "io.temporal.api.workflowservice.v1";
 option java_multiple_files = true;
 option java_outer_classname = "RequestResponseProto";
-option ruby_package = "Temporal::Api::WorkflowService::V1";
-option csharp_namespace = "Temporal.Api.WorkflowService.V1";
+option ruby_package = "Temporalio::Api::WorkflowService::V1";
+option csharp_namespace = "Temporalio.Api.WorkflowService.V1";
 
 import "temporal/api/enums/v1/batch_operation.proto";
 import "temporal/api/enums/v1/workflow.proto";
@@ -42,6 +42,7 @@ import "temporal/api/enums/v1/task_queue.proto";
 import "temporal/api/enums/v1/update.proto";
 import "temporal/api/common/v1/message.proto";
 import "temporal/api/history/v1/message.proto";
+import "temporal/api/interaction/v1/message.proto";
 import "temporal/api/workflow/v1/message.proto";
 import "temporal/api/command/v1/message.proto";
 import "temporal/api/failure/v1/message.proto";
@@ -51,7 +52,6 @@ import "temporal/api/query/v1/message.proto";
 import "temporal/api/replication/v1/message.proto";
 import "temporal/api/schedule/v1/message.proto";
 import "temporal/api/taskqueue/v1/message.proto";
-import "temporal/api/update/v1/message.proto";
 import "temporal/api/version/v1/message.proto";
 import "temporal/api/batch/v1/message.proto";
 
@@ -267,6 +267,8 @@ message PollWorkflowTaskQueueResponse {
     // Queries that should be executed after applying the history in this task. Responses should be
     // attached to `RespondWorkflowTaskCompletedRequest::query_results`
     map<string, temporal.api.query.v1.WorkflowQuery> queries = 14;
+
+    repeated temporal.api.interaction.v1.Invocation interactions = 15;
 }
 
 message RespondWorkflowTaskCompletedRequest {
@@ -304,6 +306,8 @@ message RespondWorkflowTaskCompletedResponse {
     PollWorkflowTaskQueueResponse workflow_task = 1;
     // See `ScheduleActivityTaskCommandAttributes::request_start`
     repeated PollActivityTaskQueueResponse activity_tasks = 2;
+
+    int64 reset_history_event_id = 3;
 }
 
 message RespondWorkflowTaskFailedRequest {
@@ -1067,9 +1071,12 @@ message UpdateWorkflowRequest {
     // part of the same execution chain as this id.
     string first_execution_run_id = 5;
 
+    // A string identifying the agent that requested this interaction.
+    string identity = 6;
+
     // The name under which the workflow update function is registered and the
     // arguments to pass to said function.
-    temporal.api.update.v1.WorkflowUpdate update = 6;
+    temporal.api.interaction.v1.Input input = 7;
 }
 
 message UpdateWorkflowResponse {
@@ -1077,10 +1084,7 @@ message UpdateWorkflowResponse {
     // polling if it is not returned as part of the gRPC response
     bytes update_token = 1;
     // The success or failure status of the update
-    oneof result {
-        temporal.api.common.v1.Payloads success = 2;
-        temporal.api.failure.v1.Failure failure = 3;
-    }
+    temporal.api.interaction.v1.Output output = 2;
 }
 
 message StartBatchOperationRequest {
@@ -1097,6 +1101,7 @@ message StartBatchOperationRequest {
         temporal.api.batch.v1.BatchOperationTermination termination_operation = 10;
         temporal.api.batch.v1.BatchOperationSignal signal_operation = 11;
         temporal.api.batch.v1.BatchOperationCancellation cancellation_operation = 12;
+        temporal.api.batch.v1.BatchOperationDeletion deletion_operation = 13;
     }
 }
 

package/sdk-core/protos/api_upstream/temporal/api/workflowservice/v1/service.proto

@@ -28,8 +28,8 @@ option go_package = "go.temporal.io/api/workflowservice/v1;workflowservice";
 option java_package = "io.temporal.api.workflowservice.v1";
 option java_multiple_files = true;
 option java_outer_classname = "ServiceProto";
-option ruby_package = "Temporal::Api::WorkflowService::V1";
-option csharp_namespace = "Temporal.Api.WorkflowService.V1";
+option ruby_package = "Temporalio::Api::WorkflowService::V1";
+option csharp_namespace = "Temporalio.Api.WorkflowService.V1";
 
 
 import "temporal/api/workflowservice/v1/request_response.proto";

package/sdk-core/protos/local/temporal/sdk/core/workflow_activation/workflow_activation.proto

@@ -258,6 +258,8 @@ message RemoveFromCache {
         // There was some fatal error processing the workflow, typically an internal error, but
         // can also happen if then network drops out while paginating. Check message string.
         FATAL = 8;
+        // Something went wrong attempting to fetch more history events.
+        PAGINATION_OR_HISTORY_FETCH = 9;
     }
     EvictionReason reason = 2;
 }

package/sdk-core/protos/testsrv_upstream/temporal/api/testservice/v1/request_response.proto

@@ -28,8 +28,8 @@ option go_package = "go.temporal.io/api/testservice/v1;testservice";
 option java_package = "io.temporal.api.testservice.v1";
 option java_multiple_files = true;
 option java_outer_classname = "RequestResponseProto";
-option ruby_package = "Temporal::Api::TestService::V1";
-option csharp_namespace = "Temporal.Api.TestService.V1";
+option ruby_package = "Temporalio::Api::TestService::V1";
+option csharp_namespace = "Temporalio.Api.TestService.V1";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";

package/sdk-core/protos/testsrv_upstream/temporal/api/testservice/v1/service.proto

@@ -28,8 +28,8 @@ option go_package = "go.temporal.io/api/testservice/v1;testservice";
 option java_package = "io.temporal.api.testservice.v1";
 option java_multiple_files = true;
 option java_outer_classname = "ServiceProto";
-option ruby_package = "Temporal::Api::TestService::V1";
-option csharp_namespace = "Temporal.Api.TestService.V1";
+option ruby_package = "Temporalio::Api::TestService::V1";
+option csharp_namespace = "Temporalio.Api.TestService.V1";
 
 import "temporal/api/testservice/v1/request_response.proto";
 import "google/protobuf/empty.proto";

package/sdk-core/sdk/Cargo.toml

@@ -14,21 +14,22 @@ categories = ["development-tools"]
 
 [dependencies]
 async-trait = "0.1"
+thiserror = "1.0"
 anyhow = "1.0"
-base64 = "0.13"
+base64 = "0.21"
 crossbeam = "0.8"
 derive_more = "0.99"
 futures = "0.3"
 once_cell = "1.10"
 parking_lot = { version = "0.12", features = ["send_guard"] }
-prost-types = "0.11"
+prost-types = { version = "0.4", package = "prost-wkt-types" }
 sha2 = "0.10"
 serde = "1.0"
 tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
 tokio-util = { version = "0.7" }
 tokio-stream = "0.1"
 tonic = "0.8"
-tracing = { version = "0.1", features = ["log-always"] }
+tracing = "0.1"
 
 [dependencies.temporal-sdk-core]
 path = "../core"

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

@@ -46,7 +46,6 @@ extern crate tracing;
 
 mod activity_context;
 mod app_data;
-mod conversions;
 pub mod interceptors;
 mod payload_converter;
 mod workflow_context;
@@ -67,10 +66,12 @@ use anyhow::{anyhow, bail, Context};
 use app_data::AppData;
 use futures::{future::BoxFuture, FutureExt, StreamExt, TryFutureExt, TryStreamExt};
 use std::{
+    any::{Any, TypeId},
     cell::RefCell,
     collections::HashMap,
     fmt::{Debug, Display, Formatter},
     future::Future,
+    panic::AssertUnwindSafe,
     sync::Arc,
 };
 use temporal_client::ClientOptionsBuilder;
@@ -307,22 +308,17 @@ impl Worker {
             // makes tests which use mocks dramatically more manageable.
             async {
                 if !act_half.activity_fns.is_empty() {
-                    let shutdown_token = shutdown_token.clone();
                     loop {
-                        tokio::select! {
-                            activity = common.worker.poll_activity_task() => {
-                                if matches!(activity, Err(PollActivityError::ShutDown)) {
-                                    break;
-                                }
-                                act_half.activity_task_handler(
-                                    common.worker.clone(),
-                                    safe_app_data.clone(),
-                                    common.task_queue.clone(),
-                                    activity?
-                                )?;
-                            },
-                            _ = shutdown_token.cancelled() => { break }
+                        let activity = common.worker.poll_activity_task().await;
+                        if matches!(activity, Err(PollActivityError::ShutDown)) {
+                            break;
                         }
+                        act_half.activity_task_handler(
+                            common.worker.clone(),
+                            safe_app_data.clone(),
+                            common.task_queue.clone(),
+                            activity?,
+                        )?;
                     }
                 };
                 Result::<_, anyhow::Error>::Ok(())
@@ -336,6 +332,7 @@ impl Worker {
             i.on_shutdown(self);
         }
         self.common.worker.shutdown().await;
+        debug!("Worker shutdown complete");
         self.app_data = Some(
             Arc::try_unwrap(safe_app_data)
                 .map_err(|_| anyhow!("some references of AppData exist on worker shutdown"))?,
@@ -413,7 +410,7 @@ impl WorkflowHalf {
             );
             let jh = tokio::spawn(async move {
                 tokio::select! {
-                    r = wff => r,
+                    r = wff.fuse() => r,
                     // TODO: This probably shouldn't abort early, as it could cause an in-progress
                     //  complete to abort. Send synthetic remove activation
                     _ = shutdown_token.cancelled() => {
@@ -486,15 +483,30 @@ impl ActivityHalf {
                     start,
                 );
                 tokio::spawn(async move {
-                    let output = (act_fn.act_func)(ctx, arg).await;
+                    let output = AssertUnwindSafe((act_fn.act_func)(ctx, arg))
+                        .catch_unwind()
+                        .await;
                     let result = match output {
-                        Ok(ActExitValue::Normal(p)) => ActivityExecutionResult::ok(p),
-                        Ok(ActExitValue::WillCompleteAsync) => {
+                        Err(e) => ActivityExecutionResult::fail(Failure::application_failure(
+                            format!("Activity function panicked: {}", panic_formatter(e)),
+                            true,
+                        )),
+                        Ok(Ok(ActExitValue::Normal(p))) => ActivityExecutionResult::ok(p),
+                        Ok(Ok(ActExitValue::WillCompleteAsync)) => {
                             ActivityExecutionResult::will_complete_async()
                         }
-                        Err(err) => match err.downcast::<ActivityCancelledError>() {
+                        Ok(Err(err)) => match err.downcast::<ActivityCancelledError>() {
                             Ok(ce) => ActivityExecutionResult::cancel_from_details(ce.details),
-                            Err(other_err) => ActivityExecutionResult::fail(other_err.into()),
+                            Err(other_err) => {
+                                match other_err.downcast::<NonRetryableActivityError>() {
+                                    Ok(nre) => ActivityExecutionResult::fail(
+                                        Failure::application_failure_from_error(nre.into(), true),
+                                    ),
+                                    Err(other_err) => ActivityExecutionResult::fail(
+                                        Failure::application_failure_from_error(other_err, false),
+                                    ),
+                                }
+                            }
                         },
                     };
                     worker
@@ -749,6 +761,14 @@ pub struct ActivityFunction {
 pub struct ActivityCancelledError {
     details: Option<Payload>,
 }
+impl ActivityCancelledError {
+    /// Include some details as part of concluding the activity as cancelled
+    pub fn with_details(payload: Payload) -> Self {
+        Self {
+            details: Some(payload),
+        }
+    }
+}
 impl std::error::Error for ActivityCancelledError {}
 impl Display for ActivityCancelledError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
@@ -756,6 +776,16 @@ impl Display for ActivityCancelledError {
     }
 }
 
+/// Return this error to indicate that your activity non-retryable
+/// this is a transparent wrapper around anyhow Error so essentially any type of error
+/// could be used here.
+///
+/// In your activity function. Return something along the lines of:
+/// `Err(NonRetryableActivityError(anyhow::anyhow!("This should *not* be retried")).into())`
+#[derive(Debug, thiserror::Error)]
+#[error(transparent)]
+pub struct NonRetryableActivityError(pub anyhow::Error);
+
 /// Closures / functions which can be turned into activity functions implement this trait
 pub trait IntoActivityFunc<Args, Res, Out> {
     /// Consume the closure or fn pointer and turned it into a boxed activity function
@@ -793,3 +823,39 @@ where
         Arc::new(wrapper)
     }
 }
+
+/// Attempts to turn caught panics into something printable
+fn panic_formatter(panic: Box<dyn Any>) -> Box<dyn Display> {
+    _panic_formatter::<&str>(panic)
+}
+fn _panic_formatter<T: 'static + PrintablePanicType>(panic: Box<dyn Any>) -> Box<dyn Display> {
+    match panic.downcast::<T>() {
+        Ok(d) => d,
+        Err(orig) => {
+            if TypeId::of::<<T as PrintablePanicType>::NextType>()
+                == TypeId::of::<EndPrintingAttempts>()
+            {
+                return Box::new("Couldn't turn panic into a string");
+            }
+            _panic_formatter::<T::NextType>(orig)
+        }
+    }
+}
+trait PrintablePanicType: Display {
+    type NextType: PrintablePanicType;
+}
+impl PrintablePanicType for &str {
+    type NextType = String;
+}
+impl PrintablePanicType for String {
+    type NextType = EndPrintingAttempts;
+}
+struct EndPrintingAttempts {}
+impl Display for EndPrintingAttempts {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Will never be printed")
+    }
+}
+impl PrintablePanicType for EndPrintingAttempts {
+    type NextType = EndPrintingAttempts;
+}

package/sdk-core/sdk/src/workflow_future.rs

@@ -1,7 +1,6 @@
 use crate::{
-    conversions::anyhow_to_fail, workflow_context::WfContextSharedData, CancellableID, RustWfCmd,
-    SignalData, TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction,
-    WorkflowResult,
+    panic_formatter, workflow_context::WfContextSharedData, CancellableID, RustWfCmd, SignalData,
+    TimerResult, UnblockEvent, WfContext, WfExitValue, WorkflowFunction, WorkflowResult,
 };
 use anyhow::{anyhow, bail, Context as AnyhowContext, Error};
 use crossbeam::channel::Receiver;
@@ -132,10 +131,7 @@ impl WorkflowFuture {
     fn fail_wft(&self, run_id: String, fail: Error) {
         warn!("Workflow task failed for {}: {}", run_id, fail);
         self.outgoing_completions
-            .send(WorkflowActivationCompletion::fail(
-                run_id,
-                anyhow_to_fail(fail),
-            ))
+            .send(WorkflowActivationCompletion::fail(run_id, fail.into()))
             .expect("Completion channel intact");
     }
 
@@ -218,6 +214,9 @@ impl WorkflowFuture {
                 }
 
                 Variant::RemoveFromCache(_) => {
+                    // TODO: Need to abort any spawned tasks, etc. See also cancel WF.
+                    //   How best to do this in executor agnostic way? Is that possible?
+                    //  -- tokio JoinSet does this in a nice way.
                     return Ok(true);
                 }
             }
@@ -283,11 +282,7 @@ impl Future for WorkflowFuture {
                 .poll_unpin(cx)
             {
                 Poll::Ready(Err(e)) => {
-                    let errmsg = format!(
-                        "Workflow function panicked: {:?}",
-                        // Panics are typically strings
-                        e.downcast::<String>()
-                    );
+                    let errmsg = format!("Workflow function panicked: {}", panic_formatter(e));
                     warn!("{}", errmsg);
                     self.outgoing_completions
                         .send(WorkflowActivationCompletion::fail(

package/sdk-core/sdk-core-protos/Cargo.toml

@@ -12,13 +12,15 @@ categories = ["development-tools"]
 
 [features]
 history_builders = ["uuid", "rand"]
+serde_serialize = []
 
 [dependencies]
 anyhow = "1.0"
-base64 = "0.13"
+base64 = "0.21"
 derive_more = "0.99"
 prost = "0.11"
-prost-types = "0.11"
+prost-wkt = "0.4"
+prost-wkt-types = "0.4"
 rand = { version = "0.8", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
@@ -28,3 +30,4 @@ uuid = { version = "1.1", features = ["v4"], optional = true }
 
 [build-dependencies]
 tonic-build = "0.8"
+prost-wkt-build = "0.4"

package/sdk-core/sdk-core-protos/build.rs

@@ -1,5 +1,9 @@
+use std::{env, path::PathBuf};
+
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("cargo:rerun-if-changed=../protos");
+    let out = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let descriptor_file = out.join("descriptors.bin");
     tonic_build::configure()
         // We don't actually want to build the grpc definitions - we don't need them (for now).
         // Just build the message structs.
@@ -74,7 +78,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         // All external data is useful to be able to JSON serialize, so it can render in web UI
         .type_attribute(
             ".coresdk.external_data",
-            "#[derive(::serde::Serialize, ::serde::Deserialize)]",
+            "#[cfg_attr(not(feature = \"serde_serialize\"), derive(::serde::Serialize, ::serde::Deserialize))]",
+        )
+        .type_attribute(
+            ".",
+            "#[cfg_attr(feature = \"serde_serialize\", derive(::serde::Serialize, ::serde::Deserialize))]",
         )
         .field_attribute(
             "coresdk.external_data.LocalActivityMarkerData.complete_time",
@@ -88,10 +96,26 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             "coresdk.external_data.LocalActivityMarkerData.backoff",
             "#[serde(with = \"opt_duration\")]",
         )
+        .extern_path(
+            ".google.protobuf.Any",
+            "::prost_wkt_types::Any"
+        )
+        .extern_path(
+            ".google.protobuf.Timestamp",
+            "::prost_wkt_types::Timestamp"
+        )
+        .extern_path(
+            ".google.protobuf.Duration",
+            "::prost_wkt_types::Duration"
+        )
+        .extern_path(
+            ".google.protobuf.Value",
+            "::prost_wkt_types::Value"
+        )
+        .file_descriptor_set_path(#[allow(clippy::needless_borrow)] &descriptor_file)
         .compile(
             &[
                 "../protos/local/temporal/sdk/core/core_interface.proto",
-                "../protos/local/temporal/sdk/core/bridge/bridge.proto",
                 "../protos/api_upstream/temporal/api/workflowservice/v1/service.proto",
                 "../protos/api_upstream/temporal/api/operatorservice/v1/service.proto",
                 "../protos/testsrv_upstream/temporal/api/testservice/v1/service.proto",
@@ -104,5 +128,15 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 "../protos/grpc",
             ],
         )?;
+
+    #[cfg(feature = "serde_serialize")]
+    {
+        use prost_wkt_build::{FileDescriptorSet, Message};
+
+        let descriptor_bytes = std::fs::read(descriptor_file)?;
+        let descriptor = FileDescriptorSet::decode(&descriptor_bytes[..])?;
+        prost_wkt_build::add_serde(out, descriptor);
+    }
+
     Ok(())
 }

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

@@ -18,7 +18,7 @@ use crate::{
     HistoryInfo,
 };
 use anyhow::bail;
-use prost_types::Timestamp;
+use prost_wkt_types::Timestamp;
 use std::time::{Duration, SystemTime};
 use uuid::Uuid;
 
@@ -292,22 +292,21 @@ impl TestHistoryBuilder {
         activity_id: &str,
         payload: Option<Payload>,
         failure: Option<Failure>,
-        complete_time: Option<Timestamp>,
+        detail_mutator: impl FnOnce(&mut LocalActivityMarkerData),
     ) {
+        let mut lamd = LocalActivityMarkerData {
+            seq,
+            attempt: 1,
+            activity_id: activity_id.to_string(),
+            activity_type: "some_act_type".to_string(),
+            complete_time: None,
+            backoff: None,
+            original_schedule_time: None,
+        };
+        detail_mutator(&mut lamd);
         let attrs = MarkerRecordedEventAttributes {
             marker_name: LOCAL_ACTIVITY_MARKER_NAME.to_string(),
-            details: build_local_activity_marker_details(
-                LocalActivityMarkerData {
-                    seq,
-                    attempt: 1,
-                    activity_id: activity_id.to_string(),
-                    activity_type: "some_act_type".to_string(),
-                    complete_time,
-                    backoff: None,
-                    original_schedule_time: None,
-                },
-                payload,
-            ),
+            details: build_local_activity_marker_details(lamd, payload),
             workflow_task_completed_event_id: self.previous_task_completed_id,
             failure,
             ..Default::default()
@@ -321,7 +320,7 @@ impl TestHistoryBuilder {
         activity_id: &str,
         payload: Payload,
     ) {
-        self.add_local_activity_marker(seq, activity_id, Some(payload), None, None);
+        self.add_local_activity_marker(seq, activity_id, Some(payload), None, |_| {});
     }
 
     pub fn add_local_activity_result_marker_with_time(
@@ -331,7 +330,9 @@ impl TestHistoryBuilder {
         payload: Payload,
         complete_time: Timestamp,
     ) {
-        self.add_local_activity_marker(seq, activity_id, Some(payload), None, Some(complete_time));
+        self.add_local_activity_marker(seq, activity_id, Some(payload), None, |d| {
+            d.complete_time = Some(complete_time)
+        });
     }
 
     pub fn add_local_activity_fail_marker(
@@ -340,7 +341,7 @@ impl TestHistoryBuilder {
         activity_id: &str,
         failure: Failure,
     ) {
-        self.add_local_activity_marker(seq, activity_id, None, Some(failure), None);
+        self.add_local_activity_marker(seq, activity_id, None, Some(failure), |_| {});
     }
 
     pub fn add_local_activity_cancel_marker(&mut self, seq: u32, activity_id: &str) {
@@ -358,7 +359,7 @@ impl TestHistoryBuilder {
                 )),
                 encoded_attributes: Default::default(),
             }),
-            None,
+            |_| {},
         );
     }
 
@@ -441,6 +442,12 @@ impl TestHistoryBuilder {
         );
     }
 
+    pub fn add_wfe_started_with_wft_timeout(&mut self, dur: Duration) {
+        let mut wesattrs = default_wes_attribs();
+        wesattrs.workflow_task_timeout = Some(dur.try_into().unwrap());
+        self.add(EventType::WorkflowExecutionStarted, wesattrs.into());
+    }
+
     pub fn get_orig_run_id(&self) -> &str {
         &self.original_run_id
     }
@@ -465,7 +472,7 @@ impl TestHistoryBuilder {
     }
 
     /// Return most recent wft start time or panic if unset
-    pub fn wft_start_time(&self) -> prost_types::Timestamp {
+    pub fn wft_start_time(&self) -> Timestamp {
         self.events[(self.workflow_task_scheduled_event_id + 1) as usize]
             .event_time
             .clone()

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

@@ -136,6 +136,10 @@ impl HistoryInfo {
         &self.events
     }
 
+    pub fn into_events(self) -> Vec<HistoryEvent> {
+        self.events
+    }
+
     /// Extract run id from the workflow execution started attributes.
     pub fn orig_run_id(&self) -> &str {
         &self.wf_exe_started_attrs.original_execution_run_id