@temporalio/core-bridge 1.15.0 → 1.16.1

package/sdk-core/crates/sdk-core/src/histfetch.rs

@@ -5,27 +5,37 @@
 //! We can use `clap` if this needs more arguments / other stuff later on.
 
 use prost::Message;
-use temporalio_client::{ClientOptions, WorkflowClientTrait};
+use temporalio_client::{
+    Client, ClientOptions, Connection, ConnectionOptions, NamespacedClient, WorkflowExecutionInfo,
+    WorkflowFetchHistoryOptions,
+};
+use temporalio_common::protos::temporal::api::history::v1::History;
 use url::Url;
 
 #[tokio::main]
 async fn main() -> Result<(), anyhow::Error> {
-    let url = Url::try_from("http://localhost:7233").unwrap();
-    let copts = ClientOptions::builder()
+    let copts = ConnectionOptions::new(Url::try_from("http://localhost:7233").unwrap())
         .client_name("histfetch")
         .client_version("0.0")
-        .target_url(url)
         .build();
-    let client = copts.connect("default", None).await?;
+    let connection = Connection::connect(copts).await?;
+    let client = Client::new(connection, ClientOptions::new("default").build())?;
     let wf_id = std::env::args()
         .nth(1)
         .expect("must provide workflow id as only argument");
-    let run_id = std::env::args().nth(2);
-    let hist = client
-        .get_workflow_execution_history(wf_id.clone(), run_id, vec![])
+    let run_id = std::env::args().nth(2).filter(|s| !s.is_empty());
+    let handle = WorkflowExecutionInfo {
+        namespace: client.namespace(),
+        workflow_id: wf_id.clone(),
+        run_id,
+        first_execution_run_id: None,
+    }
+    .bind_untyped(client);
+    let events = handle
+        .fetch_history(WorkflowFetchHistoryOptions::default())
         .await?
-        .history
-        .expect("history field must be populated");
+        .into_events();
+    let hist = History { events };
     // Serialize history to file
     let byteified = hist.encode_to_vec();
     tokio::fs::write(format!("{wf_id}_history.bin"), &byteified).await?;

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

@@ -2,7 +2,9 @@
 #![allow(clippy::upper_case_acronyms)]
 
 //! This crate provides a basis for creating new Temporal SDKs without completely starting from
-//! scratch
+//! scratch. APIs provided by this crate are not considered stable and may break at any time.
+//!
+//! If you are looking for the Temporal Rust SDK, please use `temporalio-sdk`.
 
 #[cfg(test)]
 #[macro_use]
@@ -32,41 +34,38 @@ mod core_tests;
 #[macro_use]
 pub mod test_help;
 
-pub(crate) use temporalio_common::errors;
-
-pub use pollers::{
-    Client, ClientOptions, ClientTlsOptions, RetryClient, RetryOptions, TlsOptions,
-    WorkflowClientTrait,
+pub use crate::worker::client::{
+    PollActivityOptions, PollOptions, PollWorkflowOptions, WorkerClient, WorkflowTaskCompletion,
 };
+pub use pollers::{Client, ClientOptions, ClientTlsOptions, RetryOptions, TlsOptions};
 pub use temporalio_common::protos::TaskToken;
 pub use url::Url;
 pub use worker::{
-    FixedSizeSlotSupplier, ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder,
-    ResourceBasedTuner, ResourceSlotOptions, SlotSupplierOptions, TunerBuilder, TunerHolder,
-    TunerHolderOptions, TunerHolderOptionsBuilder, Worker, WorkerConfig, WorkerConfigBuilder,
+    ActivitySlotKind, CompleteActivityError, CompleteNexusError, CompleteWfError,
+    FixedSizeSlotSupplier, LocalActivitySlotKind, NexusSlotKind, PollError, PollerBehavior,
+    ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder, ResourceBasedTuner,
+    ResourceSlotOptions, SlotInfo, SlotInfoTrait, SlotKind, SlotKindType, SlotMarkUsedContext,
+    SlotReleaseContext, SlotReservationContext, SlotSupplier, SlotSupplierOptions,
+    SlotSupplierPermit, TunerBuilder, TunerHolder, TunerHolderOptions, TunerHolderOptionsBuilder,
+    Worker, WorkerConfig, WorkerConfigBuilder, WorkerTuner, WorkerValidationError,
+    WorkerVersioningStrategy, WorkflowErrorType, WorkflowSlotKind,
 };
 
-/// Expose [WorkerClient] symbols
-pub use crate::worker::client::{
-    PollActivityOptions, PollOptions, PollWorkflowOptions, WorkerClient, WorkflowTaskCompletion,
-};
 use crate::{
     replay::{HistoryForReplay, ReplayWorkerInput},
-    telemetry::{
-        TelemetryInstance, metrics::MetricsContext, remove_trace_subscriber_for_current_thread,
-        set_trace_subscriber_for_current_thread, telemetry_init,
-    },
+    telemetry::metrics::MetricsContext,
     worker::client::WorkerClientBag,
 };
 use anyhow::bail;
 use futures_util::Stream;
 use std::{sync::Arc, time::Duration};
-use temporalio_client::{ConfiguredClient, NamespacedClient, SharedReplaceableClient};
+use temporalio_client::{Connection, SharedReplaceableClient};
 use temporalio_common::{
-    Worker as WorkerTrait,
-    errors::{CompleteActivityError, PollError},
     protos::coresdk::ActivityHeartbeat,
-    telemetry::TelemetryOptions,
+    telemetry::{
+        TelemetryInstance, TelemetryOptions, remove_trace_subscriber_for_current_thread,
+        set_trace_subscriber_for_current_thread, telemetry_init,
+    },
 };
 
 /// Initialize a worker bound to a task queue.
@@ -75,44 +74,37 @@ use temporalio_common::{
 /// After the worker is initialized, you should use [CoreRuntime::tokio_handle] to run the worker's
 /// async functions.
 ///
-/// Lang implementations may pass in a [ConfiguredClient] directly (or a
-/// [RetryClient] wrapping one, or a handful of other variants of the same idea). When they do so,
-/// this function will always overwrite the client retry configuration, force the client to use the
-/// namespace defined in the worker config, and set the client identity appropriately. IE: Use
-/// [ClientOptions::connect_no_namespace], not [ClientOptions::connect].
-pub fn init_worker<CT>(
+/// Lang implementations must pass in a [Client] When they do so, this function will always
+/// overwrite the client retry configuration, force the client to use the namespace defined in the
+/// worker config, and set the client identity appropriately.
+pub fn init_worker(
     runtime: &CoreRuntime,
     worker_config: WorkerConfig,
-    client: CT,
-) -> Result<Worker, anyhow::Error>
-where
-    CT: Into<sealed::AnyClient>,
-{
+    mut connection: Connection,
+) -> Result<Worker, anyhow::Error> {
     let namespace = worker_config.namespace.clone();
     if namespace.is_empty() {
         bail!("Worker namespace cannot be empty");
     }
 
-    let client = RetryClient::new(
-        SharedReplaceableClient::new(init_worker_client(
-            worker_config.namespace.clone(),
-            worker_config.client_identity_override.clone(),
-            client,
-        )),
-        RetryOptions::default(),
+    *connection.retry_options_mut() = RetryOptions::default();
+    init_worker_client(
+        &mut connection,
+        worker_config.client_identity_override.clone(),
     );
-    let client_ident = client.identity();
-    let sticky_q = sticky_q_name_for_worker(&client_ident, worker_config.max_cached_workflows);
-
+    let client = SharedReplaceableClient::new(connection);
+    let client_ident = client.inner_cow().identity().to_owned();
     if client_ident.is_empty() {
         bail!("Client identity cannot be empty. Either lang or user should be setting this value");
     }
+    let sticky_q = sticky_q_name_for_worker(&client_ident, worker_config.max_cached_workflows);
 
+    let worker_instance_key = uuid::Uuid::new_v4();
     let client_bag = Arc::new(WorkerClientBag::new(
         client,
         namespace.clone(),
-        client_ident.clone(),
         worker_config.versioning_strategy.clone(),
+        worker_instance_key,
     ));
 
     Worker::new(
@@ -141,19 +133,13 @@ where
     rwi.into_core_worker()
 }
 
-pub(crate) fn init_worker_client<CT>(
-    namespace: String,
+pub(crate) fn init_worker_client(
+    connection: &mut Connection,
     client_identity_override: Option<String>,
-    client: CT,
-) -> Client
-where
-    CT: Into<sealed::AnyClient>,
-{
-    let mut client = Client::new(*client.into().into_inner(), namespace.clone());
+) {
     if let Some(ref id_override) = client_identity_override {
-        client.options_mut().identity.clone_from(id_override);
+        connection.identity_mut().clone_from(id_override);
     }
-    client
 }
 
 /// Creates a unique sticky queue name for a worker, iff the config allows for 1 or more cached
@@ -173,63 +159,6 @@ pub(crate) fn sticky_q_name_for_worker(
     }
 }
 
-mod sealed {
-    use super::*;
-    use temporalio_client::{SharedReplaceableClient, TemporalServiceClient};
-
-    /// Allows passing different kinds of clients into things that want to be flexible. Motivating
-    /// use-case was worker initialization.
-    ///
-    /// Needs to exist in this crate to avoid blanket impl conflicts.
-    pub struct AnyClient {
-        pub(crate) inner: Box<ConfiguredClient<TemporalServiceClient>>,
-    }
-    impl AnyClient {
-        pub(crate) fn into_inner(self) -> Box<ConfiguredClient<TemporalServiceClient>> {
-            self.inner
-        }
-    }
-
-    impl From<ConfiguredClient<TemporalServiceClient>> for AnyClient {
-        fn from(c: ConfiguredClient<TemporalServiceClient>) -> Self {
-            Self { inner: Box::new(c) }
-        }
-    }
-
-    impl From<Client> for AnyClient {
-        fn from(c: Client) -> Self {
-            c.into_inner().into()
-        }
-    }
-
-    impl<T> From<RetryClient<T>> for AnyClient
-    where
-        T: Into<AnyClient>,
-    {
-        fn from(c: RetryClient<T>) -> Self {
-            c.into_inner().into()
-        }
-    }
-
-    impl<T> From<SharedReplaceableClient<T>> for AnyClient
-    where
-        T: Into<AnyClient> + Clone + Send + Sync,
-    {
-        fn from(c: SharedReplaceableClient<T>) -> Self {
-            c.inner_clone().into()
-        }
-    }
-
-    impl<T> From<Arc<T>> for AnyClient
-    where
-        T: Into<AnyClient> + Clone,
-    {
-        fn from(c: Arc<T>) -> Self {
-            Arc::unwrap_or_clone(c).into()
-        }
-    }
-}
-
 /// Holds shared state/components needed to back instances of workers and clients. More than one
 /// may be instantiated, but typically only one is needed. More than one runtime instance may be
 /// useful if multiple different telemetry settings are required.
@@ -240,7 +169,8 @@ pub struct CoreRuntime {
     heartbeat_interval: Option<Duration>,
 }
 
-/// Holds telemetry options, as well as worker heartbeat_interval. Construct with [RuntimeOptions::builder]
+/// Holds telemetry options, as well as worker heartbeat_interval. Construct with
+/// [RuntimeOptions::builder]
 #[derive(Default, bon::Builder)]
 #[builder(finish_fn(vis = "", name = build_internal))]
 #[non_exhaustive]

package/sdk-core/crates/sdk-core/src/pollers/mod.rs

@@ -3,23 +3,18 @@ mod poll_buffer;
 pub(crate) use poll_buffer::{
     ActivityTaskOptions, LongPollBuffer, WorkflowTaskOptions, WorkflowTaskPoller,
 };
-pub use temporalio_client::{
-    Client, ClientOptions, ClientTlsOptions, RetryClient, RetryOptions, TlsOptions,
-    WorkflowClientTrait,
-};
+pub use temporalio_client::{Client, ClientOptions, ClientTlsOptions, RetryOptions, TlsOptions};
 
 use crate::{
     abstractions::{OwnedMeteredSemPermit, TrackedOwnedMeteredSemPermit},
     telemetry::metrics::MetricsContext,
+    worker::{ActivitySlotKind, NexusSlotKind, SlotKind, WorkflowSlotKind},
 };
 use anyhow::{anyhow, bail};
 use futures_util::{Stream, stream};
 use std::{fmt::Debug, marker::PhantomData};
-use temporalio_common::{
-    protos::temporal::api::workflowservice::v1::{
-        PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
-    },
-    worker::{ActivitySlotKind, NexusSlotKind, SlotKind, WorkflowSlotKind},
+use temporalio_common::protos::temporal::api::workflowservice::v1::{
+    PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
 };
 use tokio::select;
 use tokio_util::sync::CancellationToken;

package/sdk-core/crates/sdk-core/src/pollers/poll_buffer.rs

@@ -2,7 +2,8 @@ use crate::{
     abstractions::{ActiveCounter, MeteredPermitDealer, OwnedMeteredSemPermit, dbg_panic},
     pollers::{self, Poller},
     worker::{
-        WFTPollerShared,
+        ActivitySlotKind, NexusSlotKind, PollerBehavior, SlotKind, WFTPollerShared,
+        WorkflowSlotKind,
         client::{PollActivityOptions, PollOptions, PollWorkflowOptions, WorkerClient},
     },
 };
@@ -23,15 +24,11 @@ use std::{
 use temporalio_client::{
     ERROR_RETURNED_DUE_TO_SHORT_CIRCUIT, request_extensions::NoRetryOnMatching,
 };
-use temporalio_common::{
-    protos::temporal::api::{
-        taskqueue::v1::PollerScalingDecision,
-        workflowservice::v1::{
-            PollActivityTaskQueueResponse, PollNexusTaskQueueResponse,
-            PollWorkflowTaskQueueResponse,
-        },
+use temporalio_common::protos::temporal::api::{
+    taskqueue::v1::PollerScalingDecision,
+    workflowservice::v1::{
+        PollActivityTaskQueueResponse, PollNexusTaskQueueResponse, PollWorkflowTaskQueueResponse,
     },
-    worker::{ActivitySlotKind, NexusSlotKind, PollerBehavior, SlotKind, WorkflowSlotKind},
 };
 use tokio::{
     sync::{
@@ -80,6 +77,7 @@ impl LongPollBuffer<PollWorkflowTaskQueueResponse, WorkflowSlotKind> {
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
         options: WorkflowTaskOptions,
         last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
+        graceful_poll_shutdown: Arc<AtomicBool>,
     ) -> Self {
         let is_sticky = sticky_queue.is_some();
         let poll_scaler = PollScaler::new(
@@ -142,6 +140,7 @@ impl LongPollBuffer<PollWorkflowTaskQueueResponse, WorkflowSlotKind> {
             poll_scaler,
             pre_permit_delay,
             post_poll_fn,
+            graceful_poll_shutdown,
         )
     }
 }
@@ -157,6 +156,7 @@ impl LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind> {
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
         options: ActivityTaskOptions,
         last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
+        graceful_poll_shutdown: Arc<AtomicBool>,
     ) -> Self {
         let pre_permit_delay = options
             .max_worker_acts_per_second
@@ -209,6 +209,7 @@ impl LongPollBuffer<PollActivityTaskQueueResponse, ActivitySlotKind> {
             poll_scaler,
             pre_permit_delay,
             None::<fn(&PollActivityTaskQueueResponse)>,
+            graceful_poll_shutdown,
         )
     }
 }
@@ -224,6 +225,7 @@ impl LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind> {
         num_pollers_handler: Option<impl Fn(usize) + Send + Sync + 'static>,
         last_successful_poll_time: Arc<AtomicCell<Option<SystemTime>>>,
         send_heartbeat: bool,
+        graceful_poll_shutdown: Arc<AtomicBool>,
     ) -> Self {
         let no_retry = if matches!(poller_behavior, PollerBehavior::Autoscaling { .. }) {
             Some(NoRetryOnMatching {
@@ -260,12 +262,13 @@ impl LongPollBuffer<PollNexusTaskQueueResponse, NexusSlotKind> {
             ),
             None::<fn() -> BoxFuture<'static, ()>>,
             None::<fn(&PollNexusTaskQueueResponse)>,
+            graceful_poll_shutdown,
         )
     }
 }
 
 // Simple way to test this w/o plumbing options through. This will be removed after
-// the proper server implementation for teminating polls on worker shutdown exists.
+// the proper server implementation for terminating polls on worker shutdown exists.
 #[cfg(test)]
 use std::cell::RefCell;
 #[cfg(test)]
@@ -285,6 +288,7 @@ where
         mut poll_scaler: PollScaler<F>,
         pre_permit_delay: Option<impl Fn() -> DelayFut + Send + Sync + 'static>,
         post_poll_fn: Option<impl Fn(&T) + Send + Sync + 'static>,
+        graceful_shutdown: Arc<AtomicBool>,
     ) -> Self
     where
         FT: Future<Output = pollers::Result<T>> + Send,
@@ -355,19 +359,22 @@ where
                         } else {
                             None
                         };
+                    let graceful_shutdown = graceful_shutdown.clone();
                     let poll_task = tokio::spawn(async move {
                         let shutdown_clone = shutdown.clone();
 
-                        // If the interrupt wait is specified, don't resolve the future that would
-                        // interrupt the poll until after the wait period.
-                        let poll_interruptor = shutdown.cancelled().then(|_| async move {
-                            if let Some(w) = poll_shutdown_interrupt_wait {
-                                tokio::time::sleep(w).await;
+                        let r = if graceful_shutdown.load(Ordering::Relaxed) {
+                            pf(timeout_override).await
+                        } else {
+                            let poll_interruptor = shutdown.cancelled().then(|_| async move {
+                                if let Some(w) = poll_shutdown_interrupt_wait {
+                                    tokio::time::sleep(w).await;
+                                }
+                            });
+                            tokio::select! {
+                                r = pf(timeout_override) => r,
+                                _ = poll_interruptor => return,
                             }
-                        });
-                        let r = tokio::select! {
-                            r = pf(timeout_override) => r,
-                            _ = poll_interruptor => return,
                         };
                         if let Ok(r) = &r
                             && let Some(ppf) = post_pf.as_ref()
@@ -846,6 +853,7 @@ mod tests {
                 wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(10)))),
             },
             Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(false)),
         );
 
         // Poll a bunch of times, "interrupting" it each time, we should only actually have polled
@@ -902,6 +910,7 @@ mod tests {
                 wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(1)))),
             },
             Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(false)),
         );
 
         // Should not see error, unwraps should get empty response
@@ -978,6 +987,7 @@ mod tests {
                 wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(10)))),
             },
             Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(false)),
         );
 
         let first_task = pb.poll().await.expect("Should get first task");
@@ -1083,6 +1093,7 @@ mod tests {
                 wft_poller_shared: Some(Arc::new(WFTPollerShared::new(Some(10)))),
             },
             Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(false)),
         ));
 
         // Trigger the first poll to initialize and get the scaling decision
@@ -1111,4 +1122,92 @@ mod tests {
             .shutdown()
             .await;
     }
+
+    #[rstest]
+    #[case::graceful(true)]
+    #[case::legacy(false)]
+    #[tokio::test]
+    async fn inflight_poll_survives_shutdown_only_when_graceful(#[case] graceful: bool) {
+        let mut mock_client = mock_manual_worker_client();
+        let task_started = Arc::new(Notify::new());
+        let task_started_clone = task_started.clone();
+        let task_complete = Arc::new(Notify::new());
+        let task_complete_clone = task_complete.clone();
+        let call_count = Arc::new(AtomicUsize::new(0));
+        let call_count_clone = call_count.clone();
+
+        mock_client
+            .expect_poll_workflow_task()
+            .returning(move |_, _| {
+                let count = call_count_clone.fetch_add(1, Ordering::SeqCst);
+                let started = task_started_clone.clone();
+                let complete = task_complete_clone.clone();
+                async move {
+                    match count {
+                        0 => Ok(PollWorkflowTaskQueueResponse {
+                            task_token: vec![1],
+                            ..Default::default()
+                        }),
+                        _ => {
+                            started.notify_one();
+                            complete.notified().await;
+                            Ok(PollWorkflowTaskQueueResponse {
+                                task_token: vec![2],
+                                ..Default::default()
+                            })
+                        }
+                    }
+                }
+                .boxed()
+            });
+
+        let shutdown_token = CancellationToken::new();
+        let pb = LongPollBuffer::new_workflow_task(
+            Arc::new(mock_client),
+            "sometq".to_string(),
+            None,
+            PollerBehavior::SimpleMaximum(1),
+            fixed_size_permit_dealer(10),
+            shutdown_token.clone(),
+            None::<fn(usize)>,
+            WorkflowTaskOptions {
+                wft_poller_shared: None,
+            },
+            Arc::new(AtomicCell::new(None)),
+            Arc::new(AtomicBool::new(graceful)),
+        );
+
+        let first = pb.poll().await.unwrap().unwrap();
+        assert_eq!(first.0.task_token, vec![1]);
+
+        // Wait for second poll to be in-flight
+        task_started.notified().await;
+
+        shutdown_token.cancel();
+
+        if graceful {
+            // Release the poll — simulates server returning empty after ShutdownWorker
+            task_complete.notify_one();
+
+            // Graceful: in-flight poll survives, second task is received
+            let second = tokio::time::timeout(Duration::from_secs(2), pb.poll())
+                .await
+                .expect("graceful poll should complete")
+                .unwrap()
+                .unwrap();
+            assert_eq!(second.0.task_token, vec![2]);
+        } else {
+            // Don't release — the poll should be killed by shutdown token before completing.
+            // Buffer drains to None because the killed poll sends no result.
+            let result = tokio::time::timeout(Duration::from_secs(2), pb.poll())
+                .await
+                .expect("legacy poll should resolve quickly");
+            assert!(
+                result.is_none(),
+                "Legacy shutdown should kill in-flight poll, buffer returns None"
+            );
+        }
+
+        pb.shutdown().await;
+    }
 }

package/sdk-core/crates/sdk-core/src/protosext/mod.rs

@@ -1,10 +1,10 @@
 pub(crate) mod protocol_messages;
 
 use crate::{
-    CompleteActivityError, TaskToken,
+    TaskToken,
     protosext::protocol_messages::IncomingProtocolMessage,
     retry_logic::ValidatedRetryPolicy,
-    worker::{LEGACY_QUERY_ID, LocalActivityExecutionResult},
+    worker::{CompleteActivityError, LEGACY_QUERY_ID, LocalActivityExecutionResult},
 };
 use anyhow::anyhow;
 use itertools::Itertools;

package/sdk-core/crates/sdk-core/src/replay/mod.rs

@@ -3,9 +3,9 @@
 //! users during testing.
 
 use crate::{
-    Worker,
+    Worker, WorkerConfig,
     worker::{
-        PostActivateHookData,
+        PollerBehavior, PostActivateHookData,
         client::mocks::{MockManualWorkerClient, mock_manual_worker_client},
     },
 };
@@ -30,7 +30,7 @@ use temporalio_common::{
             },
         },
     },
-    worker::{PollerBehavior, WorkerConfig, WorkerTaskTypes},
+    worker::WorkerTaskTypes,
 };
 use tokio::sync::{Mutex as TokioMutex, mpsc, mpsc::UnboundedSender};
 use tokio_stream::wrappers::UnboundedReceiverStream;
@@ -126,11 +126,20 @@ where
 
 /// A history which will be used during replay verification. Since histories do not include the
 /// workflow id, it must be manually attached.
-#[derive(Debug, Clone, derive_more::Constructor)]
+#[derive(Debug, Clone)]
 pub struct HistoryForReplay {
     hist: History,
     workflow_id: String,
 }
+impl HistoryForReplay {
+    /// Create a new history from replay from something that looks like a history and a workflow id.
+    pub fn new(history: impl Into<History>, workflow_id: impl Into<String>) -> Self {
+        Self {
+            hist: history.into(),
+            workflow_id: workflow_id.into(),
+        }
+    }
+}
 impl From<TestHistoryBuilder> for HistoryForReplay {
     fn from(thb: TestHistoryBuilder) -> Self {
         thb.get_full_history_info().unwrap().into()
@@ -138,7 +147,7 @@ impl From<TestHistoryBuilder> for HistoryForReplay {
 }
 impl From<HistoryInfo> for HistoryForReplay {
     fn from(histinfo: HistoryInfo) -> Self {
-        HistoryForReplay::new(histinfo.into(), "fake".to_owned())
+        HistoryForReplay::new(histinfo, "fake".to_owned())
     }
 }