Add standalone activity run id to bridge (#1189)

Author: jmaeagle99

crates/common/protos/local/temporal/sdk/core/activity_task/activity_task.proto

@@ -63,6 +63,8 @@ message Start {
     // Set to true if this is a local activity. Note that heartbeating does not apply to local
     // activities.
     bool is_local = 17;
+    // Run ID of this activity execution. Only set for standalone activities.
+    string run_id = 19;
 }
 
 // Attempt to cancel a running activity

crates/common/src/protos/mod.rs

@@ -1338,6 +1338,7 @@ pub mod coresdk {
                         retry_policy: r.retry_policy.map(fix_retry_policy),
                         priority: r.priority,
                         is_local: false,
+                        run_id: r.activity_run_id,
                     },
                 )),
             }
@@ -2931,9 +2932,52 @@ pub fn proto_ts_to_system_time(ts: &prost_types::Timestamp) -> Option<std::time:
 
 #[cfg(test)]
 mod tests {
+    use crate::protos::coresdk::activity_task;
+    use crate::protos::coresdk::activity_task::ActivityTask;
     use crate::protos::temporal::api::failure::v1::Failure;
+    use crate::protos::temporal::api::workflowservice::v1::PollActivityTaskQueueResponse;
     use anyhow::anyhow;
 
+    #[test]
+    fn start_from_poll_resp_standalone_activity_populates_run_id() {
+        let resp = PollActivityTaskQueueResponse {
+            task_token: vec![1, 2, 3],
+            activity_run_id: "test-run-id-123".to_string(),
+            activity_id: "my-activity".to_string(),
+            ..Default::default()
+        };
+        let task = ActivityTask::start_from_poll_resp(resp);
+        let start = match task.variant {
+            Some(activity_task::activity_task::Variant::Start(s)) => s,
+            _ => panic!("expected Start variant"),
+        };
+        assert_eq!(start.run_id, "test-run-id-123");
+        assert!(!start.is_local);
+    }
+
+    #[test]
+    fn start_from_poll_resp_workflow_activity_has_empty_run_id() {
+        use crate::protos::temporal::api::common::v1::WorkflowExecution;
+        let resp = PollActivityTaskQueueResponse {
+            task_token: vec![4, 5, 6],
+            activity_id: "my-workflow-activity".to_string(),
+            workflow_execution: Some(WorkflowExecution {
+                workflow_id: "wf-123".to_string(),
+                run_id: "wf-run-456".to_string(),
+            }),
+            // activity_run_id intentionally absent — this is a workflow-scheduled activity
+            ..Default::default()
+        };
+        let task = ActivityTask::start_from_poll_resp(resp);
+        let start = match task.variant {
+            Some(activity_task::activity_task::Variant::Start(s)) => s,
+            _ => panic!("expected Start variant"),
+        };
+        assert!(start.run_id.is_empty());
+        // workflow_execution is preserved and distinct from run_id
+        assert_eq!(start.workflow_execution.unwrap().run_id, "wf-run-456");
+    }
+
     #[test]
     fn anyhow_to_failure_conversion() {
         let no_causes: Failure = anyhow!("no causes").into();

crates/sdk-core/src/worker/activities/local_activities.rs

@@ -527,6 +527,7 @@ impl LocalActivityManager {
                 retry_policy: Some(sa.retry_policy.into()),
                 priority: Some(Default::default()),
                 is_local: true,
+                run_id: String::new(),
             })),
         }))
     }

crates/sdk-core/tests/integ_tests/workflow_tests/activities.rs

@@ -179,7 +179,9 @@ async fn activity_workflow() {
     assert_matches!(
         task.variant,
         Some(act_task::Variant::Start(start_activity)) => {
-            assert_eq!(start_activity.activity_type, DEFAULT_ACTIVITY_TYPE.to_string())
+            assert_eq!(start_activity.activity_type, DEFAULT_ACTIVITY_TYPE.to_string());
+            // Workflow-scheduled activities have no activity run ID
+            assert!(start_activity.run_id.is_empty());
         }
     );
     let response_payload = Payload {

crates/sdk/src/activities.rs

@@ -108,6 +108,7 @@ impl ActivityContext {
             retry_policy,
             is_local,
             priority,
+            run_id,
         } = task;
         let deadline = calculate_deadline(
             scheduled_time.as_ref(),
@@ -140,6 +141,7 @@ impl ActivityContext {
                     retry_policy,
                     is_local,
                     priority: priority.map(Into::into).unwrap_or_default(),
+                    run_id: (!run_id.is_empty()).then_some(run_id),
                 },
             },
             input,
@@ -220,6 +222,8 @@ pub struct ActivityInfo {
     pub is_local: bool,
     /// Priority of this activity. If unset uses [Priority::default].
     pub priority: Priority,
+    /// Run ID of this activity execution. Only set for standalone activities.
+    pub run_id: Option<String>,
 }
 
 /// Returned as errors from activity functions.