@temporalio/core-bridge 1.15.0 → 1.16.1

package/src/metrics.rs

@@ -5,18 +5,15 @@ use std::sync::Arc;
 use neon::prelude::*;
 use serde::Deserialize;
 
-use temporalio_common::telemetry::metrics::{
-    BufferInstrumentRef as CoreBufferInstrumentRef, CoreMeter, Counter as CoreCounter,
-    CustomMetricAttributes, Gauge as CoreGauge, Histogram as CoreHistogram, MetricCallBufferer,
-    MetricEvent as CoreMetricEvent, MetricKind as CoreMetricKind,
-    MetricParameters as CoreMetricParameters, NewAttributes, TemporalMeter,
+use temporalio_common::telemetry::metrics::core::{
+    BufferInstrumentRef as CoreBufferInstrumentRef, CustomMetricAttributes, MetricCallBufferer,
+    MetricEvent as CoreMetricEvent, MetricKind as CoreMetricKind, MetricUpdateVal,
 };
 use temporalio_common::telemetry::metrics::{
-    GaugeF64 as CoreGaugeF64, HistogramF64 as CoreHistogramF64,
-};
-use temporalio_common::telemetry::{
-    metrics,
-    metrics::{MetricKeyValue as CoreMetricKeyValue, MetricValue as CoreMetricValue},
+    Counter as CoreCounter, Gauge as CoreGauge, GaugeF64 as CoreGaugeF64,
+    Histogram as CoreHistogram, HistogramF64 as CoreHistogramF64,
+    MetricKeyValue as CoreMetricKeyValue, MetricParameters as CoreMetricParameters,
+    MetricValue as CoreMetricValue, NewAttributes, TemporalMeter,
 };
 
 use bridge_macros::{TryIntoJs, js_function};
@@ -126,7 +123,7 @@ pub fn new_metric_counter(
             "Failed to get metric meter".into(),
         ))?;
 
-    let counter = meter.inner.counter(
+    let counter = meter.counter(
         CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
@@ -152,7 +149,7 @@ pub fn new_metric_histogram(
             "Failed to get metric meter".into(),
         ))?;
 
-    let histogram = meter.inner.histogram(
+    let histogram = meter.histogram(
         CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
@@ -178,7 +175,7 @@ pub fn new_metric_histogram_f64(
             "Failed to get metric meter".into(),
         ))?;
 
-    let histogram = meter.inner.histogram_f64(
+    let histogram = meter.histogram_f64(
         CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
@@ -204,7 +201,7 @@ pub fn new_metric_gauge(
             "Failed to get metric meter".into(),
         ))?;
 
-    let gauge = meter.inner.gauge(
+    let gauge = meter.gauge(
         CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
@@ -230,7 +227,7 @@ pub fn new_metric_gauge_f64(
             "Failed to get metric meter".into(),
         ))?;
 
-    let gauge = meter.inner.gauge_f64(
+    let gauge = meter.gauge_f64(
         CoreMetricParameters::builder()
             .name(name)
             .unit(unit)
@@ -254,7 +251,6 @@ pub fn add_metric_counter_value(
 
     let attributes = counter_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
 
     counter_handle.counter.add(value as u64, &attributes);
@@ -270,7 +266,6 @@ pub fn record_metric_histogram_value(
     let histogram_handle = histogram_handle.borrow()?;
     let attributes = histogram_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
     histogram_handle.histogram.record(value, &attributes);
     Ok(())
@@ -285,7 +280,6 @@ pub fn record_metric_histogram_f64_value(
     let histogram_handle = histogram_handle.borrow()?;
     let attributes = histogram_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
     histogram_handle.histogram.record(value, &attributes);
     Ok(())
@@ -300,7 +294,6 @@ pub fn set_metric_gauge_value(
     let gauge_handle = gauge_handle.borrow()?;
     let attributes = gauge_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
     gauge_handle.gauge.record(value, &attributes);
     Ok(())
@@ -315,7 +308,6 @@ pub fn set_metric_gauge_f64_value(
     let gauge_handle = gauge_handle.borrow()?;
     let attributes = gauge_handle
         .meter
-        .inner
         .new_attributes(parse_metric_attributes(attributes.value));
     gauge_handle.gauge.record(value, &attributes);
     Ok(())
@@ -400,14 +392,14 @@ impl MetricsCallBuffer {
                 metric: instrument.get().as_ref().clone(),
                 #[allow(clippy::match_same_arms, clippy::cast_precision_loss)]
                 value: match update {
-                    metrics::MetricUpdateVal::Duration(v) if self.use_seconds_for_durations => {
+                    MetricUpdateVal::Duration(v) if self.use_seconds_for_durations => {
                         v.as_secs_f64()
                     }
-                    metrics::MetricUpdateVal::Duration(v) => v.as_millis() as f64,
-                    metrics::MetricUpdateVal::Delta(v) => *v as f64,
-                    metrics::MetricUpdateVal::DeltaF64(v) => *v,
-                    metrics::MetricUpdateVal::Value(v) => *v as f64,
-                    metrics::MetricUpdateVal::ValueF64(v) => *v,
+                    MetricUpdateVal::Duration(v) => v.as_millis() as f64,
+                    MetricUpdateVal::Delta(v) => *v as f64,
+                    MetricUpdateVal::DeltaF64(v) => *v,
+                    MetricUpdateVal::Value(v) => *v as f64,
+                    MetricUpdateVal::ValueF64(v) => *v,
                 },
                 attributes: attributes
                     .get()
@@ -508,10 +500,10 @@ impl TryIntoJs for BufferedMetricAttributes {
             let k = kv.key.as_str();
             #[allow(clippy::cast_precision_loss)]
             match &kv.value {
-                metrics::MetricValue::String(v) => object.set_property_from(cx, k, v.as_str()),
-                metrics::MetricValue::Int(v) => object.set_property_from(cx, k, *v as f64),
-                metrics::MetricValue::Float(v) => object.set_property_from(cx, k, *v),
-                metrics::MetricValue::Bool(v) => object.set_property_from(cx, k, *v),
+                CoreMetricValue::String(v) => object.set_property_from(cx, k, v.as_str()),
+                CoreMetricValue::Int(v) => object.set_property_from(cx, k, *v as f64),
+                CoreMetricValue::Float(v) => object.set_property_from(cx, k, *v),
+                CoreMetricValue::Bool(v) => object.set_property_from(cx, k, *v),
             }?;
         }
 

package/src/runtime.rs

@@ -9,10 +9,8 @@ use temporalio_common::telemetry::{
     CoreLog, OtelCollectorOptions as CoreOtelCollectorOptions,
     PrometheusExporterOptions as CorePrometheusExporterOptions, metrics::CoreMeter,
 };
-use temporalio_sdk_core::{
-    CoreRuntime, TokioRuntimeBuilder,
-    telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
-};
+use temporalio_common::telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter};
+use temporalio_sdk_core::{CoreRuntime, TokioRuntimeBuilder};
 
 use bridge_macros::js_function;
 use tokio_stream::StreamExt as _;
@@ -287,13 +285,14 @@ mod config {
     use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 
     use neon::prelude::*;
+    use temporalio_common::telemetry::CoreLogStreamConsumer;
     use temporalio_common::telemetry::{
         HistogramBucketOverrides, Logger as CoreTelemetryLogger, MetricTemporality,
         OtelCollectorOptions as CoreOtelCollectorOptions, OtlpProtocol,
         PrometheusExporterOptions as CorePrometheusExporterOptions,
         TelemetryOptions as CoreTelemetryOptions,
     };
-    use temporalio_sdk_core::{Url, telemetry::CoreLogStreamConsumer};
+    use temporalio_sdk_core::Url;
 
     use bridge_macros::TryFromJs;
 

package/src/worker.rs

@@ -6,10 +6,6 @@ use prost::Message;
 use tokio::sync::mpsc::{Sender, channel};
 use tokio_stream::wrappers::ReceiverStream;
 
-use temporalio_common::Worker as CoreWorkerTrait;
-use temporalio_common::errors::{
-    CompleteActivityError, CompleteNexusError, CompleteWfError, PollError,
-};
 use temporalio_common::protos::{
     coresdk::{
         ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
@@ -17,6 +13,7 @@ use temporalio_common::protos::{
     },
     temporal::api::history::v1::History,
 };
+use temporalio_sdk_core::{CompleteActivityError, CompleteNexusError, CompleteWfError, PollError};
 use temporalio_sdk_core::{
     CoreRuntime, init_replay_worker, init_worker,
     replay::{HistoryForReplay, ReplayWorkerInput},
@@ -82,11 +79,12 @@ pub fn worker_new(
     let config = worker_options.into_core_config()?;
 
     let client_ref = client.borrow()?;
-    let client = client_ref.core_client.clone();
+    let connection = client_ref.core_connection.clone();
     let runtime = client_ref.core_runtime.clone();
 
     enter_sync!(runtime);
-    let worker = init_worker(&runtime, config, client).context("Failed to initialize worker")?;
+    let worker =
+        init_worker(&runtime, config, connection).context("Failed to initialize worker")?;
 
     Ok(OpaqueOutboundHandle::new(Worker {
         core_runtime: runtime,
@@ -120,13 +118,13 @@ pub fn worker_replace_client(
 ) -> BridgeResult<()> {
     let worker_ref = worker.borrow()?;
     let client_ref = client.borrow()?;
-    let new_client = client_ref.core_client.clone();
+    let new_connection = client_ref.core_connection.clone();
     let runtime = worker_ref.core_runtime.clone();
 
     enter_sync!(runtime);
     worker_ref
         .core_worker
-        .replace_client(new_client)
+        .replace_client(new_connection)
         .map_err(|err| BridgeError::UnexpectedError(err.to_string()))?;
 
     Ok(())
@@ -494,14 +492,14 @@ mod config {
     use temporalio_common::protos::temporal::api::enums::v1::VersioningBehavior as CoreVersioningBehavior;
     use temporalio_common::protos::temporal::api::worker::v1::PluginInfo;
     use temporalio_common::worker::{
-        ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind,
-        PollerBehavior as CorePollerBehavior, SlotKind, WorkerConfig,
         WorkerDeploymentOptions as CoreWorkerDeploymentOptions,
-        WorkerDeploymentVersion as CoreWorkerDeploymentVersion, WorkflowSlotKind,
+        WorkerDeploymentVersion as CoreWorkerDeploymentVersion,
     };
     use temporalio_sdk_core::{
-        ResourceBasedSlotsOptions, ResourceSlotOptions,
-        SlotSupplierOptions as CoreSlotSupplierOptions, TunerHolder, TunerHolderOptions,
+        ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind,
+        PollerBehavior as CorePollerBehavior, ResourceBasedSlotsOptions, ResourceSlotOptions,
+        SlotKind, SlotSupplierOptions as CoreSlotSupplierOptions, TunerHolder, TunerHolderOptions,
+        WorkerConfig, WorkerVersioningStrategy, WorkflowSlotKind,
     };
 
     use super::custom_slot_supplier::CustomSlotSupplierOptions;
@@ -511,7 +509,6 @@ mod config {
     use neon::object::Object;
     use neon::prelude::JsResult;
     use neon::types::JsObject;
-    use temporalio_common::worker::WorkerVersioningStrategy;
 
     #[derive(TryFromJs)]
     pub struct BridgeWorkerOptions {
@@ -553,7 +550,7 @@ mod config {
     pub struct WorkerDeploymentOptions {
         version: WorkerDeploymentVersion,
         use_worker_versioning: bool,
-        default_versioning_behavior: VersioningBehavior,
+        default_versioning_behavior: Option<VersioningBehavior>,
     }
 
     #[derive(TryFromJs)]
@@ -662,7 +659,7 @@ mod config {
             Self {
                 version: val.version.into(),
                 use_worker_versioning: val.use_worker_versioning,
-                default_versioning_behavior: Some(val.default_versioning_behavior.into()),
+                default_versioning_behavior: val.default_versioning_behavior.map(Into::into),
             }
         }
     }
@@ -806,14 +803,14 @@ mod custom_slot_supplier {
 
     use neon::{context::Context, handle::Handle, prelude::*};
 
-    use temporalio_common::worker::{
+    use temporalio_sdk_core::{
         SlotInfo as CoreSlotInfo, SlotInfoTrait as _, SlotKind, SlotKindType as CoreSlotKindType,
         SlotMarkUsedContext as CoreSlotMarkUsedContext,
         SlotReleaseContext as CoreSlotReleaseContext,
         SlotReservationContext as CoreSlotReservationContext, SlotSupplier as CoreSlotSupplier,
+        SlotSupplierOptions as CoreSlotSupplierOptions,
         SlotSupplierPermit as CoreSlotSupplierPermit,
     };
-    use temporalio_sdk_core::SlotSupplierOptions as CoreSlotSupplierOptions;
 
     use bridge_macros::{TryFromJs, TryIntoJs};
     use tracing::warn;
@@ -871,7 +868,7 @@ mod custom_slot_supplier {
                     }
                     Err(err) => {
                         warn!("Error reserving slot: {err:?}");
-                        tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
+                        tokio::time::sleep(std::time::Duration::from_secs(1)).await;
                     }
                 }
             }

package/ts/native.ts

@@ -257,7 +257,7 @@ export type PollerBehavior =
 export type WorkerDeploymentOptions = {
   version: WorkerDeploymentVersion;
   useWorkerVersioning: boolean;
-  defaultVersioningBehavior: VersioningBehavior;
+  defaultVersioningBehavior: Option<VersioningBehavior>;
 };
 
 export type WorkerDeploymentVersion = {

package/sdk-core/crates/client/src/workflow_handle/mod.rs

@@ -1,212 +0,0 @@
-use crate::WorkflowService;
-use anyhow::{anyhow, bail};
-use std::{fmt::Debug, marker::PhantomData};
-use temporalio_common::protos::{
-    coresdk::FromPayloadsExt,
-    temporal::api::{
-        common::v1::{Payload, WorkflowExecution},
-        enums::v1::HistoryEventFilterType,
-        failure::v1::Failure,
-        history::v1::history_event::Attributes,
-        workflowservice::v1::GetWorkflowExecutionHistoryRequest,
-    },
-};
-use tonic::IntoRequest;
-
-/// Enumerates terminal states for a particular workflow execution
-// TODO: Add non-proto failure types, flesh out details, etc.
-#[derive(Debug)]
-#[allow(clippy::large_enum_variant)]
-pub enum WorkflowExecutionResult<T> {
-    /// The workflow finished successfully
-    Succeeded(T),
-    /// The workflow finished in failure
-    Failed(Failure),
-    /// The workflow was cancelled
-    Cancelled(Vec<Payload>),
-    /// The workflow was terminated
-    Terminated(Vec<Payload>),
-    /// The workflow timed out
-    TimedOut,
-    /// The workflow continued as new
-    ContinuedAsNew,
-}
-
-impl<T> WorkflowExecutionResult<T>
-where
-    T: Debug,
-{
-    /// Unwrap the result, panicking if it was not a success
-    pub fn unwrap_success(self) -> T {
-        match self {
-            Self::Succeeded(t) => t,
-            o => panic!("Expected success, got {o:?}"),
-        }
-    }
-}
-
-/// Options for fetching workflow results
-#[derive(Debug, Clone, Copy)]
-pub struct GetWorkflowResultOptions {
-    /// If true (the default), follows to the next workflow run in the execution chain while
-    /// retrieving results.
-    pub follow_runs: bool,
-}
-impl Default for GetWorkflowResultOptions {
-    fn default() -> Self {
-        Self { follow_runs: true }
-    }
-}
-
-/// A workflow handle which can refer to a specific workflow run, or a chain of workflow runs with
-/// the same workflow id.
-pub struct WorkflowHandle<ClientT, ResultT> {
-    client: ClientT,
-    info: WorkflowExecutionInfo,
-
-    _res_type: PhantomData<ResultT>,
-}
-
-/// Holds needed information to refer to a specific workflow run, or workflow execution chain
-#[derive(Debug)]
-pub struct WorkflowExecutionInfo {
-    /// Namespace the workflow lives in
-    pub namespace: String,
-    /// The workflow's id
-    pub workflow_id: String,
-    /// If set, target this specific run of the workflow
-    pub run_id: Option<String>,
-}
-
-impl WorkflowExecutionInfo {
-    /// Bind the workflow info to a specific client, turning it into a workflow handle
-    pub fn bind_untyped<CT>(self, client: CT) -> UntypedWorkflowHandle<CT>
-    where
-        CT: WorkflowService + Clone,
-    {
-        UntypedWorkflowHandle::new(client, self)
-    }
-}
-
-/// A workflow handle to a workflow with unknown types. Uses raw payloads.
-pub(crate) type UntypedWorkflowHandle<CT> = WorkflowHandle<CT, Vec<Payload>>;
-
-impl<CT, RT> WorkflowHandle<CT, RT>
-where
-    CT: WorkflowService + Clone,
-    // TODO: Make more generic, capable of (de)serialization w/ serde
-    RT: FromPayloadsExt,
-{
-    pub(crate) fn new(client: CT, info: WorkflowExecutionInfo) -> Self {
-        Self {
-            client,
-            info,
-            _res_type: PhantomData::<RT>,
-        }
-    }
-
-    /// Get the workflow execution info
-    pub fn info(&self) -> &WorkflowExecutionInfo {
-        &self.info
-    }
-
-    /// Get the client attached to this handle
-    pub fn client(&self) -> &CT {
-        &self.client
-    }
-
-    /// Await the result of the workflow execution
-    pub async fn get_workflow_result(
-        &self,
-        opts: GetWorkflowResultOptions,
-    ) -> Result<WorkflowExecutionResult<RT>, anyhow::Error> {
-        let mut next_page_tok = vec![];
-        let mut run_id = self.info.run_id.clone().unwrap_or_default();
-        loop {
-            let server_res = self
-                .client
-                .clone()
-                .get_workflow_execution_history(
-                    GetWorkflowExecutionHistoryRequest {
-                        namespace: self.info.namespace.to_string(),
-                        execution: Some(WorkflowExecution {
-                            workflow_id: self.info.workflow_id.clone(),
-                            run_id: run_id.clone(),
-                        }),
-                        skip_archival: true,
-                        wait_new_event: true,
-                        history_event_filter_type: HistoryEventFilterType::CloseEvent as i32,
-                        next_page_token: next_page_tok.clone(),
-                        ..Default::default()
-                    }
-                    .into_request(),
-                )
-                .await?
-                .into_inner();
-
-            let mut history = server_res
-                .history
-                .ok_or_else(|| anyhow!("Server returned an empty history!"))?;
-
-            if history.events.is_empty() {
-                next_page_tok = server_res.next_page_token;
-                continue;
-            }
-            // If page token was previously set, clear it.
-            next_page_tok = vec![];
-
-            let event_attrs = history.events.pop().and_then(|ev| ev.attributes);
-
-            macro_rules! follow {
-                ($attrs:ident) => {
-                    if opts.follow_runs && $attrs.new_execution_run_id != "" {
-                        run_id = $attrs.new_execution_run_id;
-                        continue;
-                    }
-                };
-            }
-
-            break match event_attrs {
-                Some(Attributes::WorkflowExecutionCompletedEventAttributes(attrs)) => {
-                    follow!(attrs);
-                    Ok(WorkflowExecutionResult::Succeeded(RT::from_payloads(
-                        attrs.result,
-                    )))
-                }
-                Some(Attributes::WorkflowExecutionFailedEventAttributes(attrs)) => {
-                    follow!(attrs);
-                    Ok(WorkflowExecutionResult::Failed(
-                        attrs.failure.unwrap_or_default(),
-                    ))
-                }
-                Some(Attributes::WorkflowExecutionCanceledEventAttributes(attrs)) => Ok(
-                    WorkflowExecutionResult::Cancelled(Vec::from_payloads(attrs.details)),
-                ),
-                Some(Attributes::WorkflowExecutionTimedOutEventAttributes(attrs)) => {
-                    follow!(attrs);
-                    Ok(WorkflowExecutionResult::TimedOut)
-                }
-                Some(Attributes::WorkflowExecutionTerminatedEventAttributes(attrs)) => Ok(
-                    WorkflowExecutionResult::Terminated(Vec::from_payloads(attrs.details)),
-                ),
-                Some(Attributes::WorkflowExecutionContinuedAsNewEventAttributes(attrs)) => {
-                    if opts.follow_runs {
-                        if !attrs.new_execution_run_id.is_empty() {
-                            run_id = attrs.new_execution_run_id;
-                            continue;
-                        } else {
-                            bail!("New execution run id was empty in continue as new event!");
-                        }
-                    } else {
-                        Ok(WorkflowExecutionResult::ContinuedAsNew)
-                    }
-                }
-                o => Err(anyhow!(
-                    "Server returned an event that didn't match the CloseEvent filter. \
-                     This is either a server bug or a new event the SDK does not understand. \
-                     Event details: {o:?}"
-                )),
-            };
-        }
-    }
-}

package/sdk-core/crates/common/src/errors.rs

@@ -1,85 +0,0 @@
-//! Error types exposed by public APIs
-
-use crate::protos::coresdk::activity_result::ActivityExecutionResult;
-
-/// Errors thrown by [crate::Worker::validate]
-#[derive(thiserror::Error, Debug)]
-pub enum WorkerValidationError {
-    /// The namespace provided to the worker does not exist on the server.
-    #[error("Namespace {namespace} was not found or otherwise could not be described: {source:?}")]
-    NamespaceDescribeError {
-        source: tonic::Status,
-        namespace: String,
-    },
-}
-
-/// Errors thrown by [crate::Worker] polling methods
-#[derive(thiserror::Error, Debug)]
-pub enum PollError {
-    /// [crate::Worker::shutdown] was called, and there are no more tasks to be handled from this
-    /// poll function. Lang must call [crate::Worker::complete_workflow_activation],
-    /// [crate::Worker::complete_activity_task], or
-    /// [crate::Worker::complete_nexus_task] for any remaining tasks, and then may exit.
-    #[error("Core is shut down and there are no more tasks of this kind")]
-    ShutDown,
-    /// Unhandled error when calling the temporal server. Core will attempt to retry any non-fatal
-    /// errors, so lang should consider this fatal.
-    #[error("Unhandled grpc error when polling: {0:?}")]
-    TonicError(#[from] tonic::Status),
-}
-
-/// Errors thrown by [crate::Worker::complete_workflow_activation]
-#[derive(thiserror::Error, Debug)]
-#[allow(clippy::large_enum_variant)]
-pub enum CompleteWfError {
-    /// Lang SDK sent us a malformed workflow completion. This likely means a bug in the lang sdk.
-    #[error("Lang SDK sent us a malformed workflow completion for run ({run_id}): {reason}")]
-    MalformedWorkflowCompletion {
-        /// Reason the completion was malformed
-        reason: String,
-        /// The run associated with the completion
-        run_id: String,
-    },
-    /// Workflows have not been enabled on this worker.
-    #[error("Workflows are not enabled on this worker")]
-    WorkflowNotEnabled,
-}
-
-/// Errors thrown by [crate::Worker::complete_activity_task]
-#[derive(thiserror::Error, Debug)]
-#[allow(clippy::large_enum_variant)]
-pub enum CompleteActivityError {
-    /// Lang SDK sent us a malformed activity completion. This likely means a bug in the lang sdk.
-    #[error("Lang SDK sent us a malformed activity completion ({reason}): {completion:?}")]
-    MalformedActivityCompletion {
-        /// Reason the completion was malformed
-        reason: String,
-        /// The completion, which may not be included to avoid unnecessary copies.
-        completion: Option<ActivityExecutionResult>,
-    },
-    /// Activities have not been enabled on this worker.
-    #[error("Activities are not enabled on this worker")]
-    ActivityNotEnabled,
-}
-
-/// Errors thrown by [crate::Worker::complete_nexus_task]
-#[derive(thiserror::Error, Debug)]
-pub enum CompleteNexusError {
-    /// Lang SDK sent us a malformed nexus completion. This likely means a bug in the lang sdk.
-    #[error("Lang SDK sent us a malformed nexus completion: {reason}")]
-    MalformedNexusCompletion {
-        /// Reason the completion was malformed
-        reason: String,
-    },
-    /// Nexus has not been enabled on this worker. If a user registers any Nexus handlers, the
-    #[error("Nexus is not enabled on this worker")]
-    NexusNotEnabled,
-}
-
-/// Errors we can encounter during workflow processing which we may treat as either WFT failures
-/// or whole-workflow failures depending on user preference.
-#[derive(Clone, Debug, Eq, PartialEq, Hash)]
-pub enum WorkflowErrorType {
-    /// A nondeterminism error
-    Nondeterminism,
-}