@temporalio/core-bridge 1.11.6 → 1.11.8

package/sdk-core/core/src/worker/workflow/run_cache.rs

@@ -1,18 +1,22 @@
 use crate::{
+    MetricsContext,
     telemetry::metrics::workflow_type,
     worker::workflow::{
+        HistoryUpdate, LocalActivityRequestSink, PermittedWFT, RequestEvictMsg, RunBasics,
         managed_run::{ManagedRun, RunUpdateAct},
-        HistoryUpdate, LocalActivityRequestSink, PermittedWFT, RunBasics,
     },
-    MetricsContext,
 };
 use lru::LruCache;
 use std::{num::NonZeroUsize, rc::Rc, sync::Arc};
 use temporal_sdk_core_api::worker::WorkerConfig;
-use temporal_sdk_core_protos::temporal::api::workflowservice::v1::get_system_info_response;
+use temporal_sdk_core_protos::{
+    coresdk::workflow_activation::remove_from_cache::EvictionReason,
+    temporal::api::workflowservice::v1::get_system_info_response,
+};
 
 pub(super) struct RunCache {
     worker_config: Arc<WorkerConfig>,
+    sdk_name_and_version: (String, String),
     server_capabilities: get_system_info_response::Capabilities,
     /// Run id -> Data
     runs: LruCache<String, ManagedRun>,
@@ -24,6 +28,7 @@ pub(super) struct RunCache {
 impl RunCache {
     pub(super) fn new(
         worker_config: Arc<WorkerConfig>,
+        sdk_name_and_version: (String, String),
         server_capabilities: get_system_info_response::Capabilities,
         local_activity_request_sink: impl LocalActivityRequestSink,
         metrics: MetricsContext,
@@ -37,6 +42,7 @@ impl RunCache {
         };
         Self {
             worker_config,
+            sdk_name_and_version,
             server_capabilities,
             runs: LruCache::new(
                 NonZeroUsize::new(lru_size).expect("LRU size is guaranteed positive"),
@@ -70,6 +76,8 @@ impl RunCache {
                 history: HistoryUpdate::dummy(),
                 metrics,
                 capabilities: &self.server_capabilities,
+                sdk_name: &self.sdk_name_and_version.0,
+                sdk_version: &self.sdk_name_and_version.1,
             },
             pwft,
             self.local_activity_request_sink.clone(),
@@ -84,7 +92,18 @@ impl RunCache {
     pub(super) fn remove(&mut self, k: &str) -> Option<ManagedRun> {
         let r = self.runs.pop(k);
         self.metrics.cache_size(self.len() as u64);
-        self.metrics.cache_eviction();
+        if let Some(rh) = &r {
+            // A workflow completing normally doesn't count as a forced eviction.
+            if !matches!(
+                rh.trying_to_evict(),
+                Some(RequestEvictMsg {
+                    reason: EvictionReason::WorkflowExecutionEnding,
+                    ..
+                })
+            ) {
+                self.metrics.forced_cache_eviction();
+            }
+        }
         r
     }
 

package/sdk-core/core/src/worker/workflow/wft_extraction.rs

@@ -4,15 +4,15 @@ use crate::{
     worker::{
         client::WorkerClient,
         workflow::{
-            history_update::HistoryPaginator, CacheMissFetchReq, HistoryUpdate, NextPageReq,
-            PermittedWFT,
+            CacheMissFetchReq, HistoryUpdate, NextPageReq, PermittedWFT,
+            history_update::HistoryPaginator,
         },
     },
 };
-use futures_util::{stream, stream::PollNext, FutureExt, Stream, StreamExt};
+use futures_util::{FutureExt, Stream, StreamExt, stream, stream::PollNext};
 use std::{future, sync::Arc};
 use temporal_sdk_core_api::worker::WorkflowSlotKind;
-use temporal_sdk_core_protos::{coresdk::WorkflowSlotInfo, TaskToken};
+use temporal_sdk_core_protos::{TaskToken, coresdk::WorkflowSlotInfo};
 use tracing::Span;
 
 /// Transforms incoming validated WFTs and history fetching requests into [PermittedWFT]s ready

package/sdk-core/core/src/worker/workflow/wft_poller.rs

@@ -1,10 +1,10 @@
 use crate::{
+    MetricsContext,
     abstractions::OwnedMeteredSemPermit,
     pollers::{BoxedWFPoller, Poller},
     protosext::ValidPollWFTQResponse,
-    MetricsContext,
 };
-use futures_util::{stream, Stream};
+use futures_util::{Stream, stream};
 use temporal_sdk_core_api::worker::WorkflowSlotKind;
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::PollWorkflowTaskQueueResponse;
 
@@ -78,7 +78,7 @@ mod tests {
         abstractions::tests::fixed_size_permit_dealer, pollers::MockPermittedPollBuffer,
         test_help::mock_poller,
     };
-    use futures_util::{pin_mut, StreamExt};
+    use futures_util::{StreamExt, pin_mut};
     use std::sync::Arc;
     use temporal_sdk_core_api::worker::WorkflowSlotKind;
 

package/sdk-core/core/src/worker/workflow/workflow_stream.rs

@@ -1,4 +1,5 @@
 use crate::{
+    MetricsContext,
     abstractions::dbg_panic,
     worker::workflow::{
         managed_run::RunUpdateAct,
@@ -6,11 +7,10 @@ use crate::{
         wft_extraction::{HistfetchRC, HistoryFetchReq, WFTExtractorOutput},
         *,
     },
-    MetricsContext,
 };
-use futures_util::{stream, stream::PollNext, Stream, StreamExt};
+use futures_util::{Stream, StreamExt, stream, stream::PollNext};
 use std::{collections::VecDeque, fmt::Debug, future, sync::Arc};
-use temporal_sdk_core_api::errors::PollWfError;
+use temporal_sdk_core_api::errors::PollError;
 use temporal_sdk_core_protos::coresdk::workflow_activation::remove_from_cache::EvictionReason;
 use tokio_util::sync::CancellationToken;
 use tracing::{Level, Span};
@@ -64,7 +64,7 @@ impl WFStream {
         wft_stream: impl Stream<Item = Result<WFTExtractorOutput, tonic::Status>> + Send + 'static,
         local_rx: impl Stream<Item = LocalInput> + Send + 'static,
         local_activity_request_sink: impl LocalActivityRequestSink,
-    ) -> impl Stream<Item = Result<WFStreamOutput, PollWfError>> {
+    ) -> impl Stream<Item = Result<WFStreamOutput, PollError>> {
         let all_inputs = stream::select_with_strategy(
             local_rx.map(Into::into),
             wft_stream
@@ -82,11 +82,12 @@ impl WFStream {
         all_inputs: impl Stream<Item = WFStreamInput>,
         basics: WorkflowBasics,
         local_activity_request_sink: impl LocalActivityRequestSink,
-    ) -> impl Stream<Item = Result<WFStreamOutput, PollWfError>> {
+    ) -> impl Stream<Item = Result<WFStreamOutput, PollError>> {
         let mut state = WFStream {
             buffered_polls_need_cache_slot: Default::default(),
             runs: RunCache::new(
                 basics.worker_config.clone(),
+                (basics.sdk_name.clone(), basics.sdk_version.clone()),
                 basics.server_capabilities,
                 local_activity_request_sink,
                 basics.metrics.clone(),
@@ -165,7 +166,7 @@ impl WFStream {
                         None
                     }
                     WFStreamInput::PollerError(e) => {
-                        return Err(PollWfError::TonicError(e));
+                        return Err(PollError::TonicError(e));
                     }
                 };
 
@@ -174,7 +175,7 @@ impl WFStream {
 
                 if state.shutdown_done() {
                     info!("Workflow shutdown is done");
-                    return Err(PollWfError::ShutDown);
+                    return Err(PollError::ShutDown);
                 }
 
                 Ok(WFStreamOutput {
@@ -184,7 +185,7 @@ impl WFStream {
             })
             .inspect(|o| {
                 if let Some(e) = o.as_ref().err() {
-                    if !matches!(e, PollWfError::ShutDown) {
+                    if !matches!(e, PollError::ShutDown) {
                         error!(
                             "Workflow processing encountered fatal error and must shut down {:?}",
                             e
@@ -193,7 +194,7 @@ impl WFStream {
                 }
             })
             // Stop the stream once we have shut down
-            .take_while(|o| future::ready(!matches!(o, Err(PollWfError::ShutDown))))
+            .take_while(|o| future::ready(!matches!(o, Err(PollError::ShutDown))))
     }
 
     /// Instantiate or update run machines with a new WFT
@@ -264,7 +265,12 @@ impl WFStream {
                     commands,
                     used_flags,
                     ..
-                } => match rh.successful_completion(commands, used_flags, complete.response_tx) {
+                } => match rh.successful_completion(
+                    commands,
+                    used_flags,
+                    complete.response_tx,
+                    false,
+                ) {
                     Ok(acts) => acts,
                     Err(npr) => {
                         self.runs_needing_fetching
@@ -321,7 +327,6 @@ impl WFStream {
 
         let mut res = None;
 
-        // If we reported to server, we always want to mark it complete.
         let maybe_t = self.complete_wft(run_id, report.wft_report_status);
         // Augment the WFT from complete with the permit if both exist
         let wft_from_complete = wft_from_complete.and_then(|wft| {
@@ -378,6 +383,20 @@ impl WFStream {
             if let Some(rh) = self.runs.get_mut(run_id) {
                 // Attempt to produce the next activation if needed
                 res = rh.check_more_activations();
+                // If there's no more work and we reported workflow completion to server, evict.
+                if res.is_none()
+                    && rh.workflow_is_finished()
+                    && matches!(report.wft_report_status, WFTReportStatus::Reported { .. })
+                {
+                    res = rh
+                        .request_eviction(RequestEvictMsg {
+                            run_id: run_id.to_string(),
+                            message: "Workflow completed".to_string(),
+                            reason: EvictionReason::WorkflowExecutionEnding,
+                            auto_reply_fail_tt: None,
+                        })
+                        .into_run_update_resp()
+                }
             }
         }
         res
@@ -492,7 +511,7 @@ impl WFStream {
         let num_existing_evictions = self
             .runs
             .runs_lru_order()
-            .filter(|(_, h)| h.is_trying_to_evict())
+            .filter(|(_, h)| h.trying_to_evict().is_some())
             .count();
         let mut num_evicts_needed = num_in_buff.saturating_sub(num_existing_evictions);
         for (rid, handle) in self.runs.runs_lru_order() {
@@ -546,7 +565,7 @@ impl WFStream {
         if let Some(r) = self.runs.peek(run_id) {
             info!(run_id, wft=?r.wft(), activation=?r.activation(),
                   buffered_wft=r.has_buffered_wft(),
-                  trying_to_evict=r.is_trying_to_evict(), more_work=r.more_pending_work());
+                  trying_to_evict=r.trying_to_evict().is_some(), more_work=r.more_pending_work());
         } else {
             info!(run_id, "Run not found");
         }

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

@@ -1,7 +1,7 @@
 [package]
 name = "temporal-sdk-core-api"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 authors = ["Spencer Judge <spencer@temporal.io>"]
 license-file = { workspace = true }
 description = "Interface definitions for the Temporal Core SDK"
@@ -21,9 +21,8 @@ derive_builder = { workspace = true }
 derive_more = { workspace = true }
 opentelemetry = { workspace = true, optional = true }
 prost = { workspace = true }
-prost-types = { workspace = true }
 serde_json = "1.0"
-thiserror = "1.0"
+thiserror = { workspace = true }
 tonic = { workspace = true }
 tracing-core = "0.1"
 url = "2.3"

package/sdk-core/core-api/src/errors.rs

@@ -13,30 +13,18 @@ pub enum WorkerValidationError {
     },
 }
 
-/// Errors thrown by [crate::Worker::poll_workflow_activation]
+/// Errors thrown by [crate::Worker] polling methods
 #[derive(thiserror::Error, Debug)]
-pub enum PollWfError {
-    /// [crate::Worker::shutdown] was called, and there are no more replay tasks to be handled. Lang
-    /// must call [crate::Worker::complete_workflow_activation] for any remaining tasks, and then
-    /// may exit.
-    #[error("Core is shut down and there are no more workflow replay tasks")]
+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 workflow polling: {0:?}")]
-    TonicError(#[from] tonic::Status),
-}
-
-/// Errors thrown by [crate::Worker::poll_activity_task]
-#[derive(thiserror::Error, Debug)]
-pub enum PollActivityError {
-    /// [crate::Worker::shutdown] was called, we will no longer fetch new activity tasks. Lang must
-    /// ensure it is finished with any workflow replay, see [PollWfError::ShutDown]
-    #[error("Core is shut down")]
-    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 activity polling: {0:?}")]
+    #[error("Unhandled grpc error when polling: {0:?}")]
     TonicError(#[from] tonic::Status),
 }
 
@@ -67,6 +55,20 @@ pub enum CompleteActivityError {
     },
 }
 
+/// 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)]

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

@@ -4,14 +4,17 @@ pub mod worker;
 
 use crate::{
     errors::{
-        CompleteActivityError, CompleteWfError, PollActivityError, PollWfError,
+        CompleteActivityError, CompleteNexusError, CompleteWfError, PollError,
         WorkerValidationError,
     },
     worker::WorkerConfig,
 };
 use temporal_sdk_core_protos::coresdk::{
-    activity_task::ActivityTask, workflow_activation::WorkflowActivation,
-    workflow_completion::WorkflowActivationCompletion, ActivityHeartbeat, ActivityTaskCompletion,
+    ActivityHeartbeat, ActivityTaskCompletion,
+    activity_task::ActivityTask,
+    nexus::{NexusTask, NexusTaskCompletion},
+    workflow_activation::WorkflowActivation,
+    workflow_completion::WorkflowActivationCompletion,
 };
 
 /// This trait is the primary way by which language specific SDKs interact with the core SDK.
@@ -36,14 +39,23 @@ pub trait Worker: Send + Sync {
     /// & job processing.
     ///
     /// Do not call poll concurrently. It handles polling the server concurrently internally.
-    async fn poll_workflow_activation(&self) -> Result<WorkflowActivation, PollWfError>;
+    async fn poll_workflow_activation(&self) -> Result<WorkflowActivation, PollError>;
 
     /// Ask the worker for some work, returning an [ActivityTask]. It is then the language SDK's
     /// responsibility to call the appropriate activity code with the provided inputs. Blocks
     /// indefinitely until such work is available or [Worker::shutdown] is called.
     ///
     /// Do not call poll concurrently. It handles polling the server concurrently internally.
-    async fn poll_activity_task(&self) -> Result<ActivityTask, PollActivityError>;
+    async fn poll_activity_task(&self) -> Result<ActivityTask, PollError>;
+
+    /// Ask the worker for some nexus related work. It is then the language SDK's
+    /// responsibility to call the appropriate nexus operation handler code with the provided
+    /// inputs. Blocks indefinitely until such work is available or [Worker::shutdown] is called.
+    ///
+    /// All tasks must be responded to for shutdown to complete.
+    ///
+    /// Do not call poll concurrently. It handles polling the server concurrently internally.
+    async fn poll_nexus_task(&self) -> Result<NexusTask, PollError>;
 
     /// Tell the worker that a workflow activation has completed. May (and should) be freely called
     /// concurrently. The future may take some time to resolve, as fetching more events might be
@@ -61,6 +73,13 @@ pub trait Worker: Send + Sync {
         completion: ActivityTaskCompletion,
     ) -> Result<(), CompleteActivityError>;
 
+    /// Tell the worker that a nexus task has completed. May (and should) be freely called
+    /// concurrently.
+    async fn complete_nexus_task(
+        &self,
+        completion: NexusTaskCompletion,
+    ) -> Result<(), CompleteNexusError>;
+
     /// Notify the Temporal service that an activity is still alive. Long running activities that
     /// take longer than `activity_heartbeat_timeout` to finish must call this function in order to
     /// report progress, otherwise the activity will timeout and a new attempt will be scheduled.

package/sdk-core/core-api/src/telemetry/metrics.rs

@@ -345,7 +345,7 @@ impl CustomMetricAttributes for NoOpAttributes {
 #[cfg(feature = "otel_impls")]
 mod otel_impls {
     use super::*;
-    use opentelemetry::{metrics, KeyValue};
+    use opentelemetry::{KeyValue, metrics};
 
     impl From<MetricKeyValue> for KeyValue {
         fn from(kv: MetricKeyValue) -> Self {
@@ -377,6 +377,32 @@ mod otel_impls {
         }
     }
 
+    impl Gauge for metrics::Gauge<u64> {
+        fn record(&self, value: u64, attributes: &MetricAttributes) {
+            if let MetricAttributes::OTel { kvs } = attributes {
+                self.record(value, kvs);
+            } else {
+                debug_assert!(
+                    false,
+                    "Must use OTel attributes with an OTel metric implementation"
+                );
+            }
+        }
+    }
+
+    impl GaugeF64 for metrics::Gauge<f64> {
+        fn record(&self, value: f64, attributes: &MetricAttributes) {
+            if let MetricAttributes::OTel { kvs } = attributes {
+                self.record(value, kvs);
+            } else {
+                debug_assert!(
+                    false,
+                    "Must use OTel attributes with an OTel metric implementation"
+                );
+            }
+        }
+    }
+
     impl Histogram for metrics::Histogram<u64> {
         fn record(&self, value: u64, attributes: &MetricAttributes) {
             if let MetricAttributes::OTel { kvs } = attributes {

package/sdk-core/core-api/src/telemetry.rs

@@ -68,6 +68,12 @@ pub struct OtelCollectorOptions {
     /// If set to true, use f64 seconds for durations instead of u64 milliseconds
     #[builder(default)]
     pub use_seconds_for_durations: bool,
+    /// Overrides for histogram buckets. Units depend on the value of `use_seconds_for_durations`.
+    #[builder(default)]
+    pub histogram_bucket_overrides: HistogramBucketOverrides,
+    /// Protocol to use for communication with the collector
+    #[builder(default = "OtlpProtocol::Grpc")]
+    pub protocol: OtlpProtocol,
 }
 
 /// Options for exporting metrics to Prometheus
@@ -78,15 +84,33 @@ pub struct PrometheusExporterOptions {
     #[builder(default)]
     pub global_tags: HashMap<String, String>,
     /// If set true, all counters will include a "_total" suffix
-    #[builder(default = "false")]
+    #[builder(default)]
     pub counters_total_suffix: bool,
     /// If set true, all histograms will include the unit in their name as a suffix.
     /// Ex: "_milliseconds".
-    #[builder(default = "false")]
+    #[builder(default)]
     pub unit_suffix: bool,
     /// If set to true, use f64 seconds for durations instead of u64 milliseconds
     #[builder(default)]
     pub use_seconds_for_durations: bool,
+    /// Overrides for histogram buckets. Units depend on the value of `use_seconds_for_durations`.
+    #[builder(default)]
+    pub histogram_bucket_overrides: HistogramBucketOverrides,
+}
+
+/// Allows overriding the buckets used by histogram metrics
+#[derive(Debug, Clone, Default)]
+pub struct HistogramBucketOverrides {
+    /// Overrides where the key is the metric name and the value is the list of bucket boundaries.
+    /// The metric name will apply regardless of name prefixing, if any. IE: the name acts like
+    /// `*metric_name`.
+    ///
+    /// The string names of core's built-in histogram metrics are publicly available on the
+    /// `core::telemetry` module and the `client` crate.
+    ///
+    /// See [here](https://docs.rs/opentelemetry_sdk/latest/opentelemetry_sdk/metrics/enum.Aggregation.html#variant.ExplicitBucketHistogram.field.boundaries)
+    /// for the exact meaning of boundaries.
+    pub overrides: HashMap<String, Vec<f64>>,
 }
 
 /// Control where logs go
@@ -102,7 +126,8 @@ pub enum Logger {
         /// An [EnvFilter](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/struct.EnvFilter.html) filter string.
         filter: String,
     },
-    // Push logs to Lang. Can used with temporal_sdk_core::telemetry::CoreLogBufferedConsumer to buffer.
+    /// Push logs to Lang. Can be used with
+    /// temporal_sdk_core::telemetry::log_export::CoreLogBufferedConsumer to buffer.
     Push {
         /// An [EnvFilter](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/struct.EnvFilter.html) filter string.
         filter: String,
@@ -121,6 +146,15 @@ pub enum MetricTemporality {
     Delta,
 }
 
+/// Options for configuring telemetry
+#[derive(Debug, Clone, Copy)]
+pub enum OtlpProtocol {
+    /// Use gRPC to communicate with the collector
+    Grpc,
+    /// Use HTTP to communicate with the collector
+    Http,
+}
+
 impl Default for TelemetryOptions {
     fn default() -> Self {
         TelemetryOptionsBuilder::default().build().unwrap()

package/sdk-core/core-api/src/worker.rs

@@ -6,7 +6,7 @@ use std::{
     time::Duration,
 };
 use temporal_sdk_core_protos::coresdk::{
-    ActivitySlotInfo, LocalActivitySlotInfo, WorkflowSlotInfo,
+    ActivitySlotInfo, LocalActivitySlotInfo, NexusSlotInfo, WorkflowSlotInfo,
 };
 
 const MAX_CONCURRENT_WFT_POLLS_DEFAULT: usize = 5;
@@ -56,6 +56,10 @@ pub struct WorkerConfig {
     /// worker's task queue
     #[builder(default = "5")]
     pub max_concurrent_at_polls: usize,
+    /// Maximum number of concurrent poll nexus task requests we will perform at a time on this
+    /// worker's task queue
+    #[builder(default = "5")]
+    pub max_concurrent_nexus_polls: usize,
     /// If set to true this worker will only handle workflow tasks and local activities, it will not
     /// poll for activity tasks.
     #[builder(default = "false")]
@@ -80,6 +84,8 @@ pub struct WorkerConfig {
     /// server-side. Note that this only takes effect upon an activity poll request. If multiple
     /// workers on the same queue have different values set, they will thrash with the last poller
     /// winning.
+    ///
+    /// Setting this to a nonzero value will also disable eager activity execution.
     #[builder(default)]
     pub max_task_queue_activities_per_second: Option<f64>,
 
@@ -112,8 +118,8 @@ pub struct WorkerConfig {
     #[builder(default = "5")]
     pub fetching_concurrency: usize,
 
-    /// If set, core will issue cancels for all outstanding activities after shutdown has been
-    /// initiated and this amount of time has elapsed.
+    /// If set, core will issue cancels for all outstanding activities and nexus operations after
+    /// shutdown has been initiated and this amount of time has elapsed.
     #[builder(default)]
     pub graceful_shutdown_period: Option<Duration>,
 
@@ -151,6 +157,12 @@ pub struct WorkerConfig {
     /// Mutually exclusive with `tuner`
     #[builder(setter(into, strip_option), default)]
     pub max_outstanding_local_activities: Option<usize>,
+    /// The maximum number of nexus tasks that will ever be given to this worker
+    /// concurrently
+    ///
+    /// Mutually exclusive with `tuner`
+    #[builder(setter(into, strip_option), default)]
+    pub max_outstanding_nexus_tasks: Option<usize>,
 }
 
 impl WorkerConfig {
@@ -261,6 +273,11 @@ pub trait WorkerTuner {
         &self,
     ) -> Arc<dyn SlotSupplier<SlotKind = LocalActivitySlotKind> + Send + Sync>;
 
+    /// Return a [SlotSupplier] for nexus tasks
+    fn nexus_task_slot_supplier(
+        &self,
+    ) -> Arc<dyn SlotSupplier<SlotKind = NexusSlotKind> + Send + Sync>;
+
     /// Core will call this at worker initialization time, allowing the implementation to hook up to
     /// metrics if any are configured. If not, it will not be called.
     fn attach_metrics(&self, metrics: TemporalMeter);
@@ -362,6 +379,7 @@ pub enum SlotKindType {
     Workflow,
     Activity,
     LocalActivity,
+    Nexus,
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -370,11 +388,14 @@ pub struct WorkflowSlotKind {}
 pub struct ActivitySlotKind {}
 #[derive(Debug, Copy, Clone)]
 pub struct LocalActivitySlotKind {}
+#[derive(Debug, Copy, Clone)]
+pub struct NexusSlotKind {}
 
 pub enum SlotInfo<'a> {
     Workflow(&'a WorkflowSlotInfo),
     Activity(&'a ActivitySlotInfo),
     LocalActivity(&'a LocalActivitySlotInfo),
+    Nexus(&'a NexusSlotInfo),
 }
 
 pub trait SlotInfoTrait: prost::Message {
@@ -395,6 +416,11 @@ impl SlotInfoTrait for LocalActivitySlotInfo {
         SlotInfo::LocalActivity(self)
     }
 }
+impl SlotInfoTrait for NexusSlotInfo {
+    fn downcast(&self) -> SlotInfo {
+        SlotInfo::Nexus(self)
+    }
+}
 
 pub trait SlotKind {
     type Info: SlotInfoTrait;
@@ -422,3 +448,10 @@ impl SlotKind for LocalActivitySlotKind {
         SlotKindType::LocalActivity
     }
 }
+impl SlotKind for NexusSlotKind {
+    type Info = NexusSlotInfo;
+
+    fn kind() -> SlotKindType {
+        SlotKindType::Nexus
+    }
+}

package/sdk-core/docker/docker-compose-ci.yaml

@@ -0,0 +1,25 @@
+version: '3.5'
+
+services:
+  otel-collector:
+    image: otel/opentelemetry-collector:latest
+    command: [ '--config=/etc/otel-collector-ci.yaml' ]
+    volumes:
+      - ../etc/otel-collector-ci.yaml:/etc/otel-collector-ci.yaml
+    ports:
+      #      - "1888:1888"   # pprof extension
+      # It's useful to be able to manually inspect metrics during dev
+      - '8888:8888' # Prometheus metrics exposed by the collector
+      - '8889:8889' # Prometheus exporter metrics
+      #      - "13133:13133" # health_check extension
+      - '4317:4317' # OTLP gRPC receiver
+      - '4318:4318' # OTLP HTTP receiver
+    #      - "55679:55679" # zpages extension
+
+  prometheus:
+    container_name: prometheus
+    image: prom/prometheus:latest
+    volumes:
+      - ../etc/prometheus.yaml:/etc/prometheus/prometheus.yml
+    ports:
+      - '9090:9090'