@temporalio/core-bridge 1.8.5 → 1.9.0-rc.0

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

@@ -2,7 +2,6 @@
 //! lion's share of the complexity in Core). See the `ARCHITECTURE.md` file in the repo root for
 //! a diagram of the internals.
 
-mod bridge;
 mod driven_workflow;
 mod history_update;
 mod machines;
@@ -15,11 +14,8 @@ mod workflow_stream;
 #[cfg(feature = "save_wf_inputs")]
 pub use workflow_stream::replay_wf_state_inputs;
 
-pub(crate) use bridge::WorkflowBridge;
-pub(crate) use driven_workflow::{DrivenWorkflow, WorkflowFetcher};
+pub(crate) use driven_workflow::DrivenWorkflow;
 pub(crate) use history_update::HistoryUpdate;
-#[cfg(test)]
-pub(crate) use managed_run::ManagedWFFunc;
 
 use crate::{
     abstractions::{
@@ -27,7 +23,7 @@ use crate::{
         UsedMeteredSemPermit,
     },
     internal_flags::InternalFlags,
-    protosext::legacy_query_failure,
+    protosext::{legacy_query_failure, protocol_messages::IncomingProtocolMessage},
     telemetry::{set_trace_subscriber_for_current_thread, TelemetryInstance, VecDisplayer},
     worker::{
         activities::{ActivitiesFromWFTsHandle, LocalActivityManager, TrackedPermittedTqResp},
@@ -79,6 +75,7 @@ use temporal_sdk_core_protos::{
         command::v1::{command::Attributes, Command as ProtoCommand, Command},
         common::v1::{Memo, MeteringMetadata, RetryPolicy, SearchAttributes, WorkflowExecution},
         enums::v1::WorkflowTaskFailedCause,
+        protocol::v1::Message as ProtocolMessage,
         query::v1::WorkflowQuery,
         sdk::v1::WorkflowTaskCompletedMetadata,
         taskqueue::v1::StickyExecutionAttributes,
@@ -185,7 +182,7 @@ impl Workflows {
         let (start_polling_tx, start_polling_rx) = oneshot::channel();
         // We must spawn a task to constantly poll the activation stream, because otherwise
         // activation completions would not cause anything to happen until the next poll.
-        let tracing_sub = telem_instance.map(|ti| ti.trace_subscriber());
+        let tracing_sub = telem_instance.and_then(|ti| ti.trace_subscriber());
         let processing_task = thread::spawn(move || {
             if let Some(ts) = tracing_sub {
                 set_trace_subscriber_for_current_thread(ts);
@@ -266,7 +263,6 @@ impl Workflows {
                 }
                 stream.next().await.unwrap_or(Err(PollWfError::ShutDown))?
             };
-            Span::current().record("run_id", al.run_id());
             match al {
                 ActivationOrAuto::LangActivation(mut act)
                 | ActivationOrAuto::ReadyForQueries(mut act) => {
@@ -318,7 +314,7 @@ impl Workflows {
         post_activate_hook: Option<impl Fn(PostActivateHookData)>,
     ) -> Result<(), CompleteWfError> {
         let is_empty_completion = completion.is_empty();
-        let completion = validate_completion(completion)?;
+        let completion = validate_completion(completion, is_autocomplete)?;
         let run_id = completion.run_id().to_string();
         let (tx, rx) = oneshot::channel();
         let was_sent = self.send_local(WFActCompleteMsg {
@@ -356,6 +352,7 @@ impl Workflows {
                     action:
                         ActivationAction::WftComplete {
                             mut commands,
+                            messages,
                             query_responses,
                             force_new_wft,
                             sdk_metadata,
@@ -364,10 +361,12 @@ impl Workflows {
                     let reserved_act_permits =
                         self.reserve_activity_slots_for_outgoing_commands(commands.as_mut_slice());
                     debug!(commands=%commands.display(), query_responses=%query_responses.display(),
-                           force_new_wft, "Sending responses to server");
+                           messages=%messages.display(), force_new_wft,
+                           "Sending responses to server");
                     let mut completion = WorkflowTaskCompletion {
                         task_token,
                         commands,
+                        messages,
                         query_responses,
                         sticky_attributes: None,
                         return_new_workflow_task: true,
@@ -388,26 +387,31 @@ impl Workflows {
                     }
                     completion.sticky_attributes = sticky_attrs;
 
+                    let mut reset_last_started_to = None;
                     self.handle_wft_reporting_errs(&run_id, || async {
-                        let maybe_wft = self.client.complete_workflow_task(completion).await?;
-                        if let Some(wft) = maybe_wft.workflow_task {
+                        let response = self.client.complete_workflow_task(completion).await?;
+                        if response.reset_history_event_id > 0 {
+                            reset_last_started_to = Some(response.reset_history_event_id);
+                        }
+                        if let Some(wft) = response.workflow_task {
                             wft_from_complete = Some(validate_wft(wft)?);
                         }
-                        self.handle_eager_activities(
-                            reserved_act_permits,
-                            maybe_wft.activity_tasks,
-                        );
+                        self.handle_eager_activities(reserved_act_permits, response.activity_tasks);
                         Ok(())
                     })
                     .await;
-                    WFTReportStatus::Reported
+                    WFTReportStatus::Reported {
+                        reset_last_started_to,
+                    }
                 }
                 ServerCommandsWithWorkflowInfo {
                     task_token,
                     action: ActivationAction::RespondLegacyQuery { result },
                 } => {
                     self.respond_legacy_query(task_token, *result).await;
-                    WFTReportStatus::Reported
+                    WFTReportStatus::Reported {
+                        reset_last_started_to: None,
+                    }
                 }
             },
             ActivationCompleteOutcome::ReportWFTFail(outcome) => match outcome {
@@ -419,13 +423,17 @@ impl Workflows {
                             .await
                     })
                     .await;
-                    WFTReportStatus::Reported
+                    WFTReportStatus::Reported {
+                        reset_last_started_to: None,
+                    }
                 }
                 FailedActivationWFTReport::ReportLegacyQueryFailure(task_token, failure) => {
                     warn!(run_id=%run_id, failure=?failure, "Failing legacy query request");
                     self.respond_legacy_query(task_token, legacy_query_failure(failure))
                         .await;
-                    WFTReportStatus::Reported
+                    WFTReportStatus::Reported {
+                        reset_last_started_to: None,
+                    }
                 }
             },
             ActivationCompleteOutcome::WFTFailedDontReport => WFTReportStatus::DropWft,
@@ -434,7 +442,7 @@ impl Workflows {
 
         let maybe_pwft = if let Some(wft) = wft_from_complete {
             match HistoryPaginator::from_poll(wft, self.client.clone()).await {
-                Ok((paginator, pwft)) => Some((pwft, paginator)),
+                Ok((paginator, wft)) => Some(WFTWithPaginator { wft, paginator }),
                 Err(e) => {
                     self.request_eviction(
                         &run_id,
@@ -623,7 +631,7 @@ impl Workflows {
             }
             let with_permits = reserved_act_permits
                 .into_iter()
-                .zip(eager_acts.into_iter())
+                .zip(eager_acts)
                 .map(|(permit, resp)| TrackedPermittedTqResp { permit, resp });
             if with_permits.len() > 0 {
                 debug!(
@@ -740,18 +748,9 @@ enum ActivationOrAuto {
         machines_err: WFMachinesError,
     },
 }
-impl ActivationOrAuto {
-    pub fn run_id(&self) -> &str {
-        match self {
-            ActivationOrAuto::LangActivation(act) => &act.run_id,
-            ActivationOrAuto::Autocomplete { run_id, .. } => run_id,
-            ActivationOrAuto::ReadyForQueries(act) => &act.run_id,
-            ActivationOrAuto::AutoFail { run_id, .. } => run_id,
-        }
-    }
-}
 
-/// A processed WFT which has been validated and had a history update extracted from it
+/// A WFT which is considered to be using a slot for metrics purposes and being or about to be
+/// applied to workflow state.
 #[derive(derive_more::DebugCustom)]
 #[cfg_attr(
     feature = "save_wf_inputs",
@@ -771,6 +770,18 @@ pub(crate) struct PermittedWFT {
     )]
     paginator: HistoryPaginator,
 }
+/// A WFT without a permit
+#[derive(Debug)]
+#[cfg_attr(
+    feature = "save_wf_inputs",
+    derive(serde::Serialize, serde::Deserialize)
+)]
+struct WFTWithPaginator {
+    wft: PreparedWFT,
+    paginator: HistoryPaginator,
+}
+
+/// A WFT which has been validated and had a history update extracted from it.
 #[derive(Debug)]
 #[cfg_attr(
     feature = "save_wf_inputs",
@@ -784,6 +795,7 @@ struct PreparedWFT {
     legacy_query: Option<WorkflowQuery>,
     query_requests: Vec<QueryWorkflow>,
     update: HistoryUpdate,
+    messages: Vec<IncomingProtocolMessage>,
 }
 impl PreparedWFT {
     /// Returns true if the contained history update is incremental (IE: expects to hit a cached
@@ -793,6 +805,11 @@ impl PreparedWFT {
         let poll_resp_is_incremental = start_event_id.map(|eid| eid > 1).unwrap_or_default();
         poll_resp_is_incremental || start_event_id.is_none()
     }
+
+    fn is_query_only(&self) -> bool {
+        let no_new_history = self.update.wft_started_id == 0;
+        no_new_history && self.legacy_query.is_some()
+    }
 }
 
 #[derive(Debug)]
@@ -880,6 +897,7 @@ pub(crate) enum ActivationAction {
     /// We should respond that the workflow task is complete
     WftComplete {
         commands: Vec<ProtoCommand>,
+        messages: Vec<ProtocolMessage>,
         query_responses: Vec<QueryResult>,
         force_new_wft: bool,
         sdk_metadata: WorkflowTaskCompletedMetadata,
@@ -938,7 +956,7 @@ struct LocalResolutionMsg {
 struct PostActivationMsg {
     run_id: String,
     wft_report_status: WFTReportStatus,
-    wft_from_complete: Option<(PreparedWFT, HistoryPaginator)>,
+    wft_from_complete: Option<WFTWithPaginator>,
     is_autocomplete: bool,
 }
 #[derive(Debug, Clone)]
@@ -993,7 +1011,9 @@ enum ActivationCompleteOutcome {
     derive(serde::Serialize, serde::Deserialize)
 )]
 enum WFTReportStatus {
-    Reported,
+    Reported {
+        reset_last_started_to: Option<i64>,
+    },
     /// The WFT completion was not reported when finishing the activation, because there's still
     /// work to be done. EX: Running LAs.
     NotReported,
@@ -1001,9 +1021,43 @@ enum WFTReportStatus {
     /// [ActivationCompleteOutcome::WFTFailedDontReport]
     DropWft,
 }
+#[derive(Debug, Default)]
+struct BufferedTasks {
+    /// There should only be one buffered actual WFT at a time, since any new one will immediately
+    /// supersede any old one.
+    wft: Option<PermittedWFT>,
+    /// For query only tasks, multiple may be received concurrently and it's OK to buffer more
+    /// than one - however they should be dropped if, by the time we try to process them, we
+    /// have already processed a newer real WFT than the one the query was targeting (otherwise
+    /// we'd return data from the "future").
+    query_only_tasks: VecDeque<PermittedWFT>,
+}
+
+impl BufferedTasks {
+    fn buffer(&mut self, task: PermittedWFT) {
+        if task.work.is_query_only() {
+            self.query_only_tasks.push_back(task);
+        } else {
+            let _ = self.wft.insert(task);
+        }
+    }
+
+    fn has_tasks(&self) -> bool {
+        self.wft.is_some() || !self.query_only_tasks.is_empty()
+    }
+
+    /// Remove and return the next WFT from the buffer that should be applied. WFTs which would
+    /// advance workflow state are returned before query-only tasks.
+    fn get_next_wft(&mut self) -> Option<PermittedWFT> {
+        self.wft
+            .take()
+            .or_else(|| self.query_only_tasks.pop_front())
+    }
+}
 
 fn validate_completion(
     completion: WorkflowActivationCompletion,
+    is_autocomplete: bool,
 ) -> Result<ValidatedCompletion, CompleteWfError> {
     match completion.status {
         Some(workflow_activation_completion::Status::Successful(success)) => {
@@ -1015,7 +1069,7 @@ fn validate_completion(
                 .collect::<Result<Vec<_>, EmptyWorkflowCommandErr>>()
                 .map_err(|_| CompleteWfError::MalformedWorkflowCompletion {
                     reason: "At least one workflow command in the completion contained \
-                                 an empty variant"
+                             an empty variant"
                         .to_owned(),
                     run_id: completion.run_id.clone(),
                 })?;
@@ -1055,6 +1109,7 @@ fn validate_completion(
             Ok(ValidatedCompletion::Fail {
                 run_id: completion.run_id,
                 failure,
+                is_autocomplete,
             })
         }
         None => Err(CompleteWfError::MalformedWorkflowCompletion {
@@ -1079,6 +1134,7 @@ enum ValidatedCompletion {
     Fail {
         run_id: String,
         failure: Failure,
+        is_autocomplete: bool,
     },
 }
 
@@ -1091,12 +1147,6 @@ impl ValidatedCompletion {
     }
 }
 
-#[derive(Debug)]
-pub struct OutgoingServerCommands {
-    pub commands: Vec<ProtoCommand>,
-    pub replaying: bool,
-}
-
 #[derive(Debug)]
 #[cfg_attr(
     feature = "save_wf_inputs",
@@ -1149,6 +1199,7 @@ pub enum WFCommand {
     CancelSignalWorkflow(CancelSignalWorkflow),
     UpsertSearchAttributes(UpsertWorkflowSearchAttributes),
     ModifyWorkflowProperties(ModifyWorkflowProperties),
+    UpdateResponse(UpdateResponse),
 }
 
 impl TryFrom<WorkflowCommand> for WFCommand {
@@ -1193,6 +1244,7 @@ impl TryFrom<WorkflowCommand> for WFCommand {
             workflow_command::Variant::ModifyWorkflowProperties(s) => {
                 Ok(Self::ModifyWorkflowProperties(s))
             }
+            workflow_command::Variant::UpdateResponse(s) => Ok(Self::UpdateResponse(s)),
         }
     }
 }
@@ -1340,7 +1392,7 @@ impl LocalActivityRequestSink for LAReqSink {
 /// activations must uphold.
 ///
 /// ## Ordering
-/// `patches -> signals -> other -X-> queries`
+/// `patches -> signals/updates -> other -> queries -> evictions`
 ///
 /// ## Invariants:
 /// * Queries always go in their own activation
@@ -1374,10 +1426,14 @@ fn prepare_to_ship_activation(wfa: &mut WorkflowActivation) {
             match v {
                 workflow_activation_job::Variant::NotifyHasPatch(_) => 1,
                 workflow_activation_job::Variant::SignalWorkflow(_) => 2,
+                workflow_activation_job::Variant::DoUpdate(_) => 2,
                 // In principle we should never actually need to sort these with the others, since
                 // queries always get their own activation, but, maintaining the semantic is
                 // reasonable.
                 workflow_activation_job::Variant::QueryWorkflow(_) => 4,
+                // Also shouldn't ever end up anywhere but the end by construction, but no harm in
+                // double-checking.
+                workflow_activation_job::Variant::RemoveFromCache(_) => 5,
                 _ => 3,
             }
         }
@@ -1389,6 +1445,7 @@ fn prepare_to_ship_activation(wfa: &mut WorkflowActivation) {
 mod tests {
     use super::*;
     use itertools::Itertools;
+    use temporal_sdk_core_protos::coresdk::workflow_activation::SignalWorkflow;
 
     #[test]
     fn jobs_sort() {
@@ -1396,7 +1453,10 @@ mod tests {
             jobs: vec![
                 WorkflowActivationJob {
                     variant: Some(workflow_activation_job::Variant::SignalWorkflow(
-                        Default::default(),
+                        SignalWorkflow {
+                            signal_name: "1".to_string(),
+                            ..Default::default()
+                        },
                     )),
                 },
                 WorkflowActivationJob {
@@ -1414,6 +1474,19 @@ mod tests {
                         Default::default(),
                     )),
                 },
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::DoUpdate(
+                        Default::default(),
+                    )),
+                },
+                WorkflowActivationJob {
+                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(
+                        SignalWorkflow {
+                            signal_name: "2".to_string(),
+                            ..Default::default()
+                        },
+                    )),
+                },
             ],
             ..Default::default()
         };
@@ -1427,10 +1500,12 @@ mod tests {
             variants.as_slice(),
             &[
                 workflow_activation_job::Variant::NotifyHasPatch(_),
-                workflow_activation_job::Variant::SignalWorkflow(_),
+                workflow_activation_job::Variant::SignalWorkflow(ref s1),
+                workflow_activation_job::Variant::DoUpdate(_),
+                workflow_activation_job::Variant::SignalWorkflow(ref s2),
                 workflow_activation_job::Variant::FireTimer(_),
                 workflow_activation_job::Variant::ResolveActivity(_),
-            ]
+            ] if s1.signal_name == "1" && s2.signal_name == "2"
         )
     }
 

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

@@ -7,7 +7,7 @@ use crate::{
     MetricsContext,
 };
 use lru::LruCache;
-use std::{mem, num::NonZeroUsize, rc::Rc};
+use std::{num::NonZeroUsize, rc::Rc};
 use temporal_sdk_core_protos::temporal::api::workflowservice::v1::get_system_info_response;
 
 pub(super) struct RunCache {
@@ -51,11 +51,11 @@ impl RunCache {
         }
     }
 
-    pub fn instantiate_or_update(&mut self, mut pwft: PermittedWFT) -> RunUpdateAct {
+    pub fn instantiate_or_update(&mut self, pwft: PermittedWFT) -> RunUpdateAct {
         let cur_num_cached_runs = self.runs.len();
-        let run_id = &pwft.work.execution.run_id;
+        let run_id = pwft.work.execution.run_id.clone();
 
-        if let Some(run_handle) = self.runs.get_mut(run_id) {
+        if let Some(run_handle) = self.runs.get_mut(&run_id) {
             let rur = run_handle.incoming_wft(pwft);
             self.metrics.cache_size(cur_num_cached_runs as u64);
             return rur;
@@ -66,24 +66,20 @@ impl RunCache {
         let metrics = self
             .metrics
             .with_new_attrs([workflow_type(pwft.work.workflow_type.clone())]);
-        // Replace the update in the wft with a dummy one, since we must instantiate the machines
-        // with the update.
-        let history_update = mem::replace(&mut pwft.work.update, HistoryUpdate::dummy());
-        let mut mrh = ManagedRun::new(
+        let (mrh, rur) = ManagedRun::new(
             RunBasics {
                 namespace: self.namespace.clone(),
                 workflow_id: pwft.work.execution.workflow_id.clone(),
                 workflow_type: pwft.work.workflow_type.clone(),
-                run_id: pwft.work.execution.run_id.clone(),
+                run_id: run_id.clone(),
                 task_queue: self.task_queue.clone(),
-                history: history_update,
+                history: HistoryUpdate::dummy(),
                 metrics,
                 capabilities: &self.server_capabilities,
             },
+            pwft,
             self.local_activity_request_sink.clone(),
         );
-        let run_id = run_id.to_string();
-        let rur = mrh.incoming_wft(pwft);
         if self.runs.push(run_id, mrh).is_some() {
             panic!("Overflowed run cache! Cache owner is expected to avoid this!");
         }

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

@@ -187,7 +187,7 @@ impl WFStream {
                     }
                 };
 
-                activations.extend(maybe_act.into_iter());
+                activations.extend(maybe_act);
                 activations.extend(state.reconcile_buffered());
 
                 // Always flush *after* actually handling the input, as this allows LA sink
@@ -301,10 +301,19 @@ impl WFStream {
                         None
                     }
                 },
-                ValidatedCompletion::Fail { failure, .. } => rh.failed_completion(
+                ValidatedCompletion::Fail {
+                    failure,
+                    is_autocomplete,
+                    ..
+                } => rh.failed_completion(
                     failure.force_cause(),
-                    EvictionReason::LangFail,
+                    if is_autocomplete {
+                        EvictionReason::Unspecified
+                    } else {
+                        EvictionReason::LangFail
+                    },
                     failure,
+                    is_autocomplete,
                     complete.response_tx,
                 ),
             },
@@ -324,7 +333,8 @@ impl WFStream {
     fn process_post_activation(&mut self, report: PostActivationMsg) -> RunUpdateAct {
         let run_id = &report.run_id;
         let wft_from_complete = report.wft_from_complete;
-        if let Some((wft, _)) = &wft_from_complete {
+        if let Some(WFTWithPaginator { wft, .. }) = &wft_from_complete {
+            debug!(run_id=%wft.execution.run_id, "New WFT from completion");
             if &wft.execution.run_id != run_id {
                 dbg_panic!(
                     "Server returned a WFT on completion for a different run ({}) than the \
@@ -339,48 +349,45 @@ impl WFStream {
 
         // 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| {
+            maybe_t.map(|t| PermittedWFT {
+                work: wft.wft,
+                paginator: wft.paginator,
+                permit: t.permit,
+            })
+        });
         // Delete the activation, but only if the report came from lang, or we know the outstanding
         // activation is expected to be completed internally.
-        if let Some(activation) = self.runs.get_mut(run_id).and_then(|rh| {
-            rh.delete_activation(|act| {
+        if let Some((should_evict, mut maybe_buffered)) = self.runs.get_mut(run_id).map(|rh| {
+            rh.finish_activation(|act| {
                 !report.is_autocomplete || matches!(act, OutstandingActivation::Autocomplete)
             })
         }) {
-            // Evict the run if the activation contained an eviction
-            let mut applied_buffered_poll_for_this_run = false;
-            if activation.has_eviction() {
+            if should_evict {
                 debug!(run_id=%run_id, "Evicting run");
-
-                if let Some(mut rh) = self.runs.remove(run_id) {
-                    if let Some(buff) = rh.take_buffered_wft() {
-                        // Don't try to apply a buffered poll for this run if we just got a new WFT
-                        // from completing, because by definition that buffered poll is now an
-                        // out-of-date WFT.
-                        if wft_from_complete.is_none() {
-                            res = self.instantiate_or_update(buff);
-                            applied_buffered_poll_for_this_run = true;
+                self.runs.remove(run_id);
+            }
+            let maybe_ready_wft =
+                maybe_buffered
+                    .get_next_wft()
+                    .or(wft_from_complete)
+                    .or_else(|| {
+                        // Attempt to apply a buffered poll for some *other* run, if we didn't have a
+                        // wft from complete or a buffered poll for *this* run and we evicted
+                        if should_evict {
+                            self.buffered_polls_need_cache_slot.pop_front()
+                        } else {
+                            None
                         }
-                    }
+                    });
+            if let Some(wft) = maybe_ready_wft {
+                res = self.instantiate_or_update(wft);
+                // We accept that there might be query tasks remaining in the buffer if we evicted
+                // and re-instantiated here. It's likely those tasks are now invalidated anyway.
+                if maybe_buffered.has_tasks() && should_evict {
+                    panic!("There were leftover buffered tasks");
                 }
-
-                // Attempt to apply a buffered poll for some *other* run, if we didn't have a wft
-                // from complete or a buffered poll for *this* run.
-                if wft_from_complete.is_none() && !applied_buffered_poll_for_this_run {
-                    if let Some(buff) = self.buffered_polls_need_cache_slot.pop_front() {
-                        res = self.instantiate_or_update(buff);
-                    }
-                }
-            };
-        }
-
-        if let Some((wft, pag)) = wft_from_complete {
-            debug!(run_id=%wft.execution.run_id, "New WFT from completion");
-            if let Some(t) = maybe_t {
-                res = self.instantiate_or_update(PermittedWFT {
-                    work: wft,
-                    permit: t.permit,
-                    paginator: pag,
-                });
             }
         }
 

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

@@ -12,22 +12,23 @@ categories = ["development-tools"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+otel_impls = ["opentelemetry"]
+
 [dependencies]
 async-trait = "0.1"
 derive_builder = "0.12"
+derive_more = "0.99"
+opentelemetry = { workspace = true, optional = true }
 prost-types = "0.11"
 serde = { version = "1.0", default_features = false, features = ["derive"] }
 serde_json = "1.0"
 thiserror = "1.0"
 tokio = "1.24"
-tonic = "0.8"
+tonic = { workspace = true }
 tracing-core = "0.1"
 url = "2.3"
 
 [dependencies.temporal-sdk-core-protos]
 path = "../sdk-core-protos"
-version = "0.1"
-
-[dependencies.temporal-client]
-path = "../client"
-version = "0.1"
+version = "0.1"

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

@@ -24,25 +24,17 @@ pub trait Worker: Send + Sync {
     /// be one outstanding activation for a particular run of a workflow at any time. If an
     /// activation is not responded to, it will cause that workflow to become stuck forever.
     ///
-    /// Activations that contain only a `remove_from_cache` job should not cause the workflow code
-    /// to be invoked and may be responded to with an empty command list. Eviction jobs may also
-    /// appear with other jobs, but will always appear last in the job list. In this case it is
-    /// expected that the workflow code will be invoked, and the response produced as normal, but
-    /// the caller should evict the run after doing so.
+    /// See [WorkflowActivation] for more details on the expected behavior of lang w.r.t activation
+    /// & job processing.
     ///
-    /// It is rarely a good idea to call poll concurrently. It handles polling the server
-    /// concurrently internally.
+    /// Do not call poll concurrently. It handles polling the server concurrently internally.
     async fn poll_workflow_activation(&self) -> Result<WorkflowActivation, PollWfError>;
 
     /// 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.
     ///
-    /// The returned activation is guaranteed to be for the same task queue / worker which was
-    /// provided as the `task_queue` argument.
-    ///
-    /// It is rarely a good idea to call poll concurrently. It handles polling the server
-    /// concurrently internally.
+    /// Do not call poll concurrently. It handles polling the server concurrently internally.
     async fn poll_activity_task(&self) -> Result<ActivityTask, PollActivityError>;
 
     /// Tell the worker that a workflow activation has completed. May (and should) be freely called