@temporalio/core-bridge 1.6.0 → 1.7.1

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

@@ -1,11 +1,12 @@
 syntax = "proto3";
 
-/**
+/*
  * Definitions for commands from a workflow in lang SDK to core. While a workflow processes a batch
  * of activation jobs, it accumulates these commands to be sent back to core to conclude that
  * activation.
  */
 package coresdk.workflow_commands;
+option ruby_package = "Temporalio::Bridge::Api::WorkflowCommands";
 
 import "google/protobuf/duration.proto";
 import "google/protobuf/timestamp.proto";
@@ -40,118 +41,118 @@ message WorkflowCommand {
 }
 
 message StartTimer {
-    /// Lang's incremental sequence number, used as the operation identifier
+    // Lang's incremental sequence number, used as the operation identifier
     uint32 seq = 1;
     google.protobuf.Duration start_to_fire_timeout = 2;
 }
 
 message CancelTimer {
-    /// Lang's incremental sequence number as passed to `StartTimer`
+    // Lang's incremental sequence number as passed to `StartTimer`
     uint32 seq = 1;
 }
 
 message ScheduleActivity {
-    /// Lang's incremental sequence number, used as the operation identifier
+    // Lang's incremental sequence number, used as the operation identifier
     uint32 seq = 1;
     string activity_id = 2;
     string activity_type = 3;
     // The name of the task queue to place this activity request in
     string task_queue = 5;
     map<string, temporal.api.common.v1.Payload> headers = 6;
-    /// Arguments/input to the activity. Called "input" upstream.
+    // Arguments/input to the activity. Called "input" upstream.
     repeated temporal.api.common.v1.Payload arguments = 7;
-    /// Indicates how long the caller is willing to wait for an activity completion. Limits how long
-    /// retries will be attempted. Either this or start_to_close_timeout_seconds must be specified.
-    /// When not specified defaults to the workflow execution timeout.
+    // Indicates how long the caller is willing to wait for an activity completion. Limits how long
+    // retries will be attempted. Either this or start_to_close_timeout_seconds must be specified.
+    // When not specified defaults to the workflow execution timeout.
     google.protobuf.Duration schedule_to_close_timeout = 8;
-    /// Limits time an activity task can stay in a task queue before a worker picks it up. This
-    /// timeout is always non retryable as all a retry would achieve is to put it back into the same
-    /// queue. Defaults to schedule_to_close_timeout or workflow execution timeout if not specified.
+    // Limits time an activity task can stay in a task queue before a worker picks it up. This
+    // timeout is always non retryable as all a retry would achieve is to put it back into the same
+    // queue. Defaults to schedule_to_close_timeout or workflow execution timeout if not specified.
     google.protobuf.Duration schedule_to_start_timeout = 9;
-    /// Maximum time an activity is allowed to execute after a pick up by a worker. This timeout is
-    /// always retryable. Either this or schedule_to_close_timeout must be specified.
+    // Maximum time an activity is allowed to execute after a pick up by a worker. This timeout is
+    // always retryable. Either this or schedule_to_close_timeout must be specified.
     google.protobuf.Duration start_to_close_timeout = 10;
-    /// Maximum time allowed between successful worker heartbeats.
+    // Maximum time allowed between successful worker heartbeats.
     google.protobuf.Duration heartbeat_timeout = 11;
-    /// Activities are provided by a default retry policy controlled through the service dynamic
-    /// configuration. Retries are happening up to schedule_to_close_timeout. To disable retries set
-    /// retry_policy.maximum_attempts to 1.
+    // Activities are provided by a default retry policy controlled through the service dynamic
+    // configuration. Retries are happening up to schedule_to_close_timeout. To disable retries set
+    // retry_policy.maximum_attempts to 1.
     temporal.api.common.v1.RetryPolicy retry_policy = 12;
-    /// Defines how the workflow will wait (or not) for cancellation of the activity to be confirmed
+    // Defines how the workflow will wait (or not) for cancellation of the activity to be confirmed
     ActivityCancellationType cancellation_type = 13;
-    /// If set, the worker will not tell the service that it can immediately start executing this
-    /// activity. When unset/default, workers will always attempt to do so if activity execution
-    /// slots are available.
+    // If set, the worker will not tell the service that it can immediately start executing this
+    // activity. When unset/default, workers will always attempt to do so if activity execution
+    // slots are available.
     bool do_not_eagerly_execute = 14;
 }
 
 message ScheduleLocalActivity {
-    /// Lang's incremental sequence number, used as the operation identifier
+    // Lang's incremental sequence number, used as the operation identifier
     uint32 seq = 1;
     string activity_id = 2;
     string activity_type = 3;
-    /// Local activities can start with a non-1 attempt, if lang has been told to backoff using
-    /// a timer before retrying. It should pass the attempt number from a `DoBackoff` activity
-    /// resolution.
+    // Local activities can start with a non-1 attempt, if lang has been told to backoff using
+    // a timer before retrying. It should pass the attempt number from a `DoBackoff` activity
+    // resolution.
     uint32 attempt = 4;
-    /// If this local activity is a retry (as per the attempt field) this needs to be the original
-    /// scheduling time (as provided in `DoBackoff`)
+    // If this local activity is a retry (as per the attempt field) this needs to be the original
+    // scheduling time (as provided in `DoBackoff`)
     google.protobuf.Timestamp original_schedule_time = 5;
     map<string, temporal.api.common.v1.Payload> headers = 6;
-    /// Arguments/input to the activity.
+    // Arguments/input to the activity.
     repeated temporal.api.common.v1.Payload arguments = 7;
-    /// Indicates how long the caller is willing to wait for local activity completion. Limits how
-    /// long retries will be attempted. When not specified defaults to the workflow execution
-    /// timeout (which may be unset).
+    // Indicates how long the caller is willing to wait for local activity completion. Limits how
+    // long retries will be attempted. When not specified defaults to the workflow execution
+    // timeout (which may be unset).
     google.protobuf.Duration schedule_to_close_timeout = 8;
-    /// Limits time the local activity can idle internally before being executed. That can happen if
-    /// the worker is currently at max concurrent local activity executions. This timeout is always
-    /// non retryable as all a retry would achieve is to put it back into the same queue. Defaults
-    /// to `schedule_to_close_timeout` if not specified and that is set. Must be <=
-    /// `schedule_to_close_timeout` when set, otherwise, it will be clamped down.
+    // Limits time the local activity can idle internally before being executed. That can happen if
+    // the worker is currently at max concurrent local activity executions. This timeout is always
+    // non retryable as all a retry would achieve is to put it back into the same queue. Defaults
+    // to `schedule_to_close_timeout` if not specified and that is set. Must be <=
+    // `schedule_to_close_timeout` when set, otherwise, it will be clamped down.
     google.protobuf.Duration schedule_to_start_timeout = 9;
-    /// Maximum time the local activity is allowed to execute after the task is dispatched. This
-    /// timeout is always retryable. Either or both of `schedule_to_close_timeout` and this must be
-    /// specified. If set, this must be <= `schedule_to_close_timeout`, otherwise, it will be
-    /// clamped down.
+    // Maximum time the local activity is allowed to execute after the task is dispatched. This
+    // timeout is always retryable. Either or both of `schedule_to_close_timeout` and this must be
+    // specified. If set, this must be <= `schedule_to_close_timeout`, otherwise, it will be
+    // clamped down.
     google.protobuf.Duration start_to_close_timeout = 10;
-    /// Specify a retry policy for the local activity. By default local activities will be retried
-    /// indefinitely.
+    // Specify a retry policy for the local activity. By default local activities will be retried
+    // indefinitely.
     temporal.api.common.v1.RetryPolicy retry_policy = 11;
-    /// If the activity is retrying and backoff would exceed this value, lang will be told to
-    /// schedule a timer and retry the activity after. Otherwise, backoff will happen internally in
-    /// core. Defaults to 1 minute.
+    // If the activity is retrying and backoff would exceed this value, lang will be told to
+    // schedule a timer and retry the activity after. Otherwise, backoff will happen internally in
+    // core. Defaults to 1 minute.
     google.protobuf.Duration local_retry_threshold = 12;
-    /// Defines how the workflow will wait (or not) for cancellation of the activity to be
-    /// confirmed. Lang should default this to `WAIT_CANCELLATION_COMPLETED`, even though proto
-    /// will default to `TRY_CANCEL` automatically.
+    // Defines how the workflow will wait (or not) for cancellation of the activity to be
+    // confirmed. Lang should default this to `WAIT_CANCELLATION_COMPLETED`, even though proto
+    // will default to `TRY_CANCEL` automatically.
     ActivityCancellationType cancellation_type = 13;
 }
 
 enum ActivityCancellationType {
-    /// Initiate a cancellation request and immediately report cancellation to the workflow.
+    // Initiate a cancellation request and immediately report cancellation to the workflow.
     TRY_CANCEL = 0;
-    /// Wait for activity cancellation completion. Note that activity must heartbeat to receive a
-    /// cancellation notification. This can block the cancellation for a long time if activity
-    /// doesn't heartbeat or chooses to ignore the cancellation request.
+    // Wait for activity cancellation completion. Note that activity must heartbeat to receive a
+    // cancellation notification. This can block the cancellation for a long time if activity
+    // doesn't heartbeat or chooses to ignore the cancellation request.
     WAIT_CANCELLATION_COMPLETED = 1;
-    /// Do not request cancellation of the activity and immediately report cancellation to the
-    /// workflow
+    // Do not request cancellation of the activity and immediately report cancellation to the
+    // workflow
     ABANDON = 2;
 }
 
 message RequestCancelActivity {
-    /// Lang's incremental sequence number as passed to `ScheduleActivity`
+    // Lang's incremental sequence number as passed to `ScheduleActivity`
     uint32 seq = 1;
 }
 
 message RequestCancelLocalActivity {
-    /// Lang's incremental sequence number as passed to `ScheduleLocalActivity`
+    // Lang's incremental sequence number as passed to `ScheduleLocalActivity`
     uint32 seq = 1;
 }
 
 message QueryResult {
-    /// Corresponds to the id provided in the activation job
+    // Corresponds to the id provided in the activation job
     string query_id = 1;
     oneof variant {
         QuerySuccess succeeded = 2;
@@ -163,12 +164,12 @@ message QuerySuccess {
     temporal.api.common.v1.Payload response = 1;
 }
 
-/// Issued when the workflow completes successfully
+// Issued when the workflow completes successfully
 message CompleteWorkflowExecution {
     temporal.api.common.v1.Payload result = 1;
 }
 
-/// Issued when the workflow errors out
+// Issued when the workflow errors out
 message FailWorkflowExecution {
     temporal.api.failure.v1.Failure failure = 1;
 }
@@ -199,11 +200,11 @@ message ContinueAsNewWorkflowExecution {
     temporal.api.common.v1.RetryPolicy retry_policy = 9;
 }
 
-/// Indicate a workflow has completed as cancelled. Generally sent as a response to an activation
-/// containing a cancellation job.
+// Indicate a workflow has completed as cancelled. Generally sent as a response to an activation
+// containing a cancellation job.
 message CancelWorkflowExecution {}
 
-/// A request to set/check if a certain patch is present or not
+// A request to set/check if a certain patch is present or not
 message SetPatchMarker {
     // A user-chosen identifier for this patch. If the same identifier is used in multiple places in
     // the code, those places are considered to be versioned as one unit. IE: The check call will
@@ -214,47 +215,47 @@ message SetPatchMarker {
     bool deprecated = 2;
 }
 
-/// Start a child workflow execution
+// Start a child workflow execution
 message StartChildWorkflowExecution {
-    /// Lang's incremental sequence number, used as the operation identifier
+    // Lang's incremental sequence number, used as the operation identifier
     uint32 seq = 1;
     string namespace = 2;
     string workflow_id = 3;
     string workflow_type = 4;
     string task_queue = 5;
     repeated temporal.api.common.v1.Payload input = 6;
-    /// Total workflow execution timeout including retries and continue as new.
+    // Total workflow execution timeout including retries and continue as new.
     google.protobuf.Duration workflow_execution_timeout = 7;
-    /// Timeout of a single workflow run.
+    // Timeout of a single workflow run.
     google.protobuf.Duration workflow_run_timeout = 8;
-    /// Timeout of a single workflow task.
+    // Timeout of a single workflow task.
     google.protobuf.Duration workflow_task_timeout = 9;
-    /// Default: PARENT_CLOSE_POLICY_TERMINATE.
+    // Default: PARENT_CLOSE_POLICY_TERMINATE.
     child_workflow.ParentClosePolicy parent_close_policy = 10;
     // string control = 11; (unused from StartChildWorkflowExecutionCommandAttributes)
     // Default: WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE.
     temporal.api.enums.v1.WorkflowIdReusePolicy workflow_id_reuse_policy = 12;
     temporal.api.common.v1.RetryPolicy retry_policy = 13;
     string cron_schedule = 14;
-    /// Header fields
+    // Header fields
     map<string, temporal.api.common.v1.Payload> headers = 15;
-    /// Memo fields
+    // Memo fields
     map<string, temporal.api.common.v1.Payload> memo = 16;
-    /// Search attributes
+    // Search attributes
     map<string, temporal.api.common.v1.Payload> search_attributes = 17;
-    /// Defines behaviour of the underlying workflow when child workflow cancellation has been requested.
+    // Defines behaviour of the underlying workflow when child workflow cancellation has been requested.
     child_workflow.ChildWorkflowCancellationType cancellation_type = 18;
 }
 
-/// Cancel a child workflow
+// Cancel a child workflow
 message CancelChildWorkflowExecution {
     // Sequence number as given to the `StartChildWorkflowExecution` command
     uint32 child_workflow_seq = 1;
 }
 
-/// Request cancellation of an external workflow execution (which may be a started child)
+// Request cancellation of an external workflow execution (which may be a started child)
 message RequestCancelExternalWorkflowExecution {
-    /// Lang's incremental sequence number, used as the operation identifier
+    // Lang's incremental sequence number, used as the operation identifier
     uint32 seq = 1;
     // What workflow is being targeted
     oneof target {
@@ -265,9 +266,9 @@ message RequestCancelExternalWorkflowExecution {
     }
 }
 
-/// Send a signal to an external or child workflow
+// Send a signal to an external or child workflow
 message SignalExternalWorkflowExecution {
-    /// Lang's incremental sequence number, used as the operation identifier
+    // Lang's incremental sequence number, used as the operation identifier
     uint32 seq = 1;
     // What workflow is being targeted
     oneof target {
@@ -276,23 +277,23 @@ message SignalExternalWorkflowExecution {
         // The desired target must be a child of the issuing workflow, and this is its workflow id
         string child_workflow_id = 3;
     }
-    /// Name of the signal handler
+    // Name of the signal handler
     string signal_name = 4;
-    /// Arguments for the handler
+    // Arguments for the handler
     repeated temporal.api.common.v1.Payload args = 5;
-    /// Headers to attach to the signal
+    // Headers to attach to the signal
     map<string, temporal.api.common.v1.Payload> headers = 6;
 }
 
-/// Can be used to cancel not-already-sent `SignalExternalWorkflowExecution` commands
+// Can be used to cancel not-already-sent `SignalExternalWorkflowExecution` commands
 message CancelSignalWorkflow {
-    /// Lang's incremental sequence number as passed to `SignalExternalWorkflowExecution`
+    // Lang's incremental sequence number as passed to `SignalExternalWorkflowExecution`
     uint32 seq = 1;
 }
 
 message UpsertWorkflowSearchAttributes {
-    /// SearchAttributes fields - equivalent to indexed_fields on api. Key = search index, Value =
-    /// value?
+    // SearchAttributes fields - equivalent to indexed_fields on api. Key = search index, Value =
+    // value?
     map<string, temporal.api.common.v1.Payload> search_attributes = 1;
 }
 

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

@@ -1,12 +1,14 @@
 syntax = "proto3";
 
 package coresdk.workflow_completion;
+option ruby_package = "Temporalio::Bridge::Api::WorkflowCompletion";
 
 import "temporal/api/failure/v1/message.proto";
+import "temporal/api/enums/v1/failed_cause.proto";
 import "temporal/sdk/core/common/common.proto";
 import "temporal/sdk/core/workflow_commands/workflow_commands.proto";
 
-/// Result of a single workflow activation, reported from lang to core
+// Result of a single workflow activation, reported from lang to core
 message WorkflowActivationCompletion {
     // The run id from the workflow activation you are completing
     string run_id = 1;
@@ -16,14 +18,18 @@ message WorkflowActivationCompletion {
     }
 }
 
-/// Successful workflow activation with a list of commands generated by the workflow execution
+// Successful workflow activation with a list of commands generated by the workflow execution
 message Success {
     // A list of commands to send back to the temporal server
     repeated workflow_commands.WorkflowCommand commands = 1;
+    // Any internal flags which the lang SDK used in the processing of this activation
+    repeated uint32 used_internal_flags = 6;
 }
 
-/// Failure to activate or execute a workflow
+// Failure to activate or execute a workflow
 message Failure {
     temporal.api.failure.v1.Failure failure = 1;
+    // Forces overriding the WFT failure cause
+    temporal.api.enums.v1.WorkflowTaskFailedCause force_cause = 2;
 }
 

package/sdk-core/sdk/Cargo.toml

@@ -25,7 +25,7 @@ parking_lot = { version = "0.12", features = ["send_guard"] }
 prost-types = { version = "0.4", package = "prost-wkt-types" }
 sha2 = "0.10"
 serde = "1.0"
-tokio = { version = "1.1", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
+tokio = { version = "1.26", features = ["rt", "rt-multi-thread", "parking_lot", "time", "fs"] }
 tokio-util = { version = "0.7" }
 tokio-stream = "0.1"
 tonic = "0.8"

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

@@ -88,7 +88,7 @@ use temporal_sdk_core_protos::{
         common::NamespacedWorkflowExecution,
         workflow_activation::{
             resolve_child_workflow_execution_start::Status as ChildWorkflowStartStatus,
-            workflow_activation_job::Variant, WorkflowActivation, WorkflowActivationJob,
+            workflow_activation_job::Variant, WorkflowActivation,
         },
         workflow_commands::{workflow_command, ContinueAsNewWorkflowExecution},
         workflow_completion::WorkflowActivationCompletion,
@@ -391,10 +391,10 @@ impl WorkflowHalf {
 
         // If the activation is to start a workflow, create a new workflow driver for it,
         // using the function associated with that workflow id
-        if let Some(WorkflowActivationJob {
-            variant: Some(Variant::StartWorkflow(sw)),
-        }) = activation.jobs.get(0)
-        {
+        if let Some(sw) = activation.jobs.iter().find_map(|j| match j.variant {
+            Some(Variant::StartWorkflow(ref sw)) => Some(sw),
+            _ => None,
+        }) {
             let workflow_type = &sw.workflow_type;
             let wf_fns_borrow = self.workflow_fns.borrow();
             let wf_function = wf_fns_borrow
@@ -549,11 +549,13 @@ pub enum TimerResult {
 }
 
 /// Successful result of sending a signal to an external workflow
+#[derive(Debug)]
 pub struct SignalExternalOk;
 /// Result of awaiting on sending a signal to an external workflow
 pub type SignalExternalWfResult = Result<SignalExternalOk, Failure>;
 
 /// Successful result of sending a cancel request to an external workflow
+#[derive(Debug)]
 pub struct CancelExternalOk;
 /// Result of awaiting on sending a cancel request to an external workflow
 pub type CancelExternalWfResult = Result<CancelExternalOk, Failure>;
@@ -656,6 +658,20 @@ pub enum CancellableID {
     },
 }
 
+impl CancellableID {
+    /// Returns the type-specific sequence number used for this command
+    pub fn seq_num(&self) -> u32 {
+        match self {
+            CancellableID::Timer(seq) => *seq,
+            CancellableID::Activity(seq) => *seq,
+            CancellableID::LocalActivity(seq) => *seq,
+            CancellableID::ChildWorkflow(seq) => *seq,
+            CancellableID::SignalExternalWorkflow(seq) => *seq,
+            CancellableID::ExternalWorkflow { seqnum, .. } => *seqnum,
+        }
+    }
+}
+
 #[derive(derive_more::From)]
 #[allow(clippy::large_enum_variant)]
 enum RustWfCmd {

package/sdk-core/sdk/src/workflow_context/options.rs

@@ -9,7 +9,10 @@ use temporal_sdk_core_protos::{
             StartChildWorkflowExecution,
         },
     },
-    temporal::api::common::v1::{Payload, RetryPolicy},
+    temporal::api::{
+        common::v1::{Payload, RetryPolicy},
+        enums::v1::ParentClosePolicy,
+    },
 };
 
 // TODO: Before release, probably best to avoid using proto types entirely here. They're awkward.
@@ -180,6 +183,8 @@ pub struct ChildWorkflowOptions {
     pub cancel_type: ChildWorkflowCancellationType,
     /// Common options
     pub options: WorkflowOptions,
+    /// How to respond to parent workflow ending
+    pub parent_close_policy: ParentClosePolicy,
 }
 
 impl IntoWorkflowCommand for ChildWorkflowOptions {
@@ -203,6 +208,7 @@ impl IntoWorkflowCommand for ChildWorkflowOptions {
             workflow_task_timeout: self.options.task_timeout.and_then(|d| d.try_into().ok()),
             search_attributes: self.options.search_attributes.unwrap_or_default(),
             cron_schedule: self.options.cron_schedule.unwrap_or_default(),
+            parent_close_policy: self.parent_close_policy as i32,
             ..Default::default()
         }
     }

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

@@ -34,7 +34,8 @@ use temporal_sdk_core_protos::{
         workflow_commands::{
             request_cancel_external_workflow_execution as cancel_we,
             signal_external_workflow_execution as sig_we, workflow_command,
-            ModifyWorkflowProperties, RequestCancelExternalWorkflowExecution, SetPatchMarker,
+            CancelChildWorkflowExecution, ModifyWorkflowProperties,
+            RequestCancelExternalWorkflowExecution, SetPatchMarker,
             SignalExternalWorkflowExecution, StartTimer, UpsertWorkflowSearchAttributes,
         },
     },
@@ -98,6 +99,7 @@ pub struct WfContextSharedData {
     pub changes: HashMap<String, bool>,
     pub is_replaying: bool,
     pub wf_time: Option<SystemTime>,
+    pub history_length: u32,
 }
 
 // TODO: Dataconverter type interface to replace Payloads here. Possibly just use serde
@@ -148,6 +150,11 @@ impl WfContext {
         self.shared.read().wf_time
     }
 
+    /// Return the length of history so far at this point in the workflow
+    pub fn history_length(&self) -> u32 {
+        self.shared.read().history_length
+    }
+
     pub(crate) fn get_shared_data(&self) -> Arc<RwLock<WfContextSharedData>> {
         self.shared.clone()
     }
@@ -550,16 +557,16 @@ impl<'a> Future for LATimerBackoffFut<'a> {
         }
         let poll_res = self.current_fut.poll_unpin(cx);
         if let Poll::Ready(ref r) = poll_res {
-            // If we've already said we want to cancel, don't schedule the backoff timer. Just
-            // return cancel status. This can happen if cancel comes after the LA says it wants to
-            // back off but before we have scheduled the timer.
-            if self.did_cancel.load(Ordering::Acquire) {
-                return Poll::Ready(ActivityResolution {
-                    status: Some(activity_resolution::Status::Cancelled(Default::default())),
-                });
-            }
-
             if let Some(activity_resolution::Status::Backoff(b)) = r.status.as_ref() {
+                // If we've already said we want to cancel, don't schedule the backoff timer. Just
+                // return cancel status. This can happen if cancel comes after the LA says it wants
+                // to back off but before we have scheduled the timer.
+                if self.did_cancel.load(Ordering::Acquire) {
+                    return Poll::Ready(ActivityResolution {
+                        status: Some(activity_resolution::Status::Cancelled(Default::default())),
+                    });
+                }
+
                 let timer_f = self.ctx.timer(
                     b.backoff_duration
                         .clone()
@@ -673,13 +680,13 @@ impl StartedChildWorkflow {
     }
 
     /// Cancel the child workflow
-    pub fn cancel(&self, cx: &WfContext) -> impl Future<Output = CancelExternalWfResult> {
-        let target = NamespacedWorkflowExecution {
-            namespace: cx.namespace().to_string(),
-            workflow_id: self.common.workflow_id.clone(),
-            ..Default::default()
-        };
-        cx.cancel_external(target)
+    pub fn cancel(&self, cx: &WfContext) {
+        cx.send(RustWfCmd::NewNonblockingCmd(
+            CancelChildWorkflowExecution {
+                child_workflow_seq: self.common.result_future.cancellable_id.seq_num(),
+            }
+            .into(),
+        ));
     }
 
     /// Signal the child workflow

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

@@ -62,7 +62,9 @@ impl WorkflowFunction {
                 // We need to mark the workflow future as unconstrained, otherwise Tokio will impose
                 // an artificial limit on how many commands we can unblock in one poll round.
                 // TODO: Now we *need* deadlock detection or we could hose the whole system
-                inner: tokio::task::unconstrained((self.wf_func)(wf_context)).boxed(),
+                inner: tokio::task::unconstrained((self.wf_func)(wf_context))
+                    .fuse()
+                    .boxed(),
                 incoming_commands: cmd_receiver,
                 outgoing_completions,
                 incoming_activations,
@@ -179,8 +181,11 @@ impl WorkflowFuture {
                     Box::new(result.context("Child Workflow execution must have a result")?),
                 ))?,
                 Variant::UpdateRandomSeed(_) => (),
-                Variant::QueryWorkflow(_) => {
-                    todo!()
+                Variant::QueryWorkflow(q) => {
+                    error!(
+                        "Queries are not implemented in the Rust SDK. Got query '{}'",
+                        q.query_id
+                    );
                 }
                 Variant::CancelWorkflow(_) => {
                     // TODO: Cancel pending futures, etc
@@ -252,6 +257,7 @@ impl Future for WorkflowFuture {
                 let mut wlock = self.ctx_shared.write();
                 wlock.is_replaying = activation.is_replaying;
                 wlock.wf_time = activation.timestamp.try_into_or_none();
+                wlock.history_length = activation.history_length;
             }
 
             let mut die_of_eviction_when_done = false;