bump core to 45b1d7e, plumb plugins to core, add LA test

Author: yuandrew

packages/core-bridge/sdk-core

@@ -166,6 +166,9 @@ pub fn worker_complete_workflow_activation(
                         ),
                     }
                 }
+                CompleteWfError::WorkflowNotEnabled => {
+                    BridgeError::UnexpectedError(format!("{err}"))
+                }
             })
     })
 }
@@ -225,6 +228,9 @@ pub fn worker_complete_activity_task(
                     field: None,
                     message: format!("Malformed Activity Completion: {reason:?}"),
                 },
+                CompleteActivityError::ActivityNotEnabled => {
+                    BridgeError::UnexpectedError(format!("{err}"))
+                }
             })
     })
 }
@@ -466,6 +472,7 @@ mod config {
     use std::{sync::Arc, time::Duration};
 
     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, WorkerConfigBuilder,
@@ -499,14 +506,15 @@ mod config {
         workflow_task_poller_behavior: PollerBehavior,
         activity_task_poller_behavior: PollerBehavior,
         nexus_task_poller_behavior: PollerBehavior,
-        enable_non_local_activities: bool,
+        task_types: WorkerTaskTypes,
         sticky_queue_schedule_to_start_timeout: Duration,
         max_cached_workflows: usize,
         max_heartbeat_throttle_interval: Duration,
         default_heartbeat_throttle_interval: Duration,
         max_activities_per_second: Option<f64>,
         max_task_queue_activities_per_second: Option<f64>,
         shutdown_grace_time: Option<Duration>,
+        plugins: Vec<String>,
     }
 
     #[derive(TryFromJs)]
@@ -540,6 +548,25 @@ mod config {
         AutoUpgrade,
     }
 
+    #[derive(TryFromJs)]
+    pub struct WorkerTaskTypes {
+        enable_workflows: bool,
+        enable_local_activities: bool,
+        enable_remote_activities: bool,
+        enable_nexus: bool,
+    }
+
+    impl From<&WorkerTaskTypes> for temporalio_common::worker::WorkerTaskTypes {
+        fn from(t: &WorkerTaskTypes) -> Self {
+            Self {
+                enable_workflows: t.enable_workflows,
+                enable_local_activities: t.enable_local_activities,
+                enable_remote_activities: t.enable_remote_activities,
+                enable_nexus: t.enable_nexus,
+            }
+        }
+    }
+
     impl BridgeWorkerOptions {
         pub(crate) fn into_core_config(self) -> Result<WorkerConfig, WorkerConfigBuilderError> {
             // Set all other options
@@ -566,14 +593,23 @@ mod config {
                 .workflow_task_poller_behavior(self.workflow_task_poller_behavior)
                 .activity_task_poller_behavior(self.activity_task_poller_behavior)
                 .nexus_task_poller_behavior(self.nexus_task_poller_behavior)
-                .no_remote_activities(!self.enable_non_local_activities)
+                .task_types(&self.task_types)
                 .sticky_queue_schedule_to_start_timeout(self.sticky_queue_schedule_to_start_timeout)
                 .max_cached_workflows(self.max_cached_workflows)
                 .max_heartbeat_throttle_interval(self.max_heartbeat_throttle_interval)
                 .default_heartbeat_throttle_interval(self.default_heartbeat_throttle_interval)
                 .max_task_queue_activities_per_second(self.max_task_queue_activities_per_second)
                 .max_worker_activities_per_second(self.max_activities_per_second)
                 .graceful_shutdown_period(self.shutdown_grace_time)
+                .plugins(
+                    self.plugins
+                        .into_iter()
+                        .map(|name| PluginInfo {
+                            name,
+                            version: String::new(),
+                        })
+                        .collect::<Vec<_>>(),
+                )
                 .build()
         }
     }

packages/core-bridge/src/worker.rs

@@ -213,14 +213,20 @@ export interface WorkerOptions {
   workflowTaskPollerBehavior: PollerBehavior;
   activityTaskPollerBehavior: PollerBehavior;
   nexusTaskPollerBehavior: PollerBehavior;
-  enableNonLocalActivities: boolean;
+  taskTypes: {
+    enableWorkflows: boolean;
+    enableLocalActivities: boolean;
+    enableRemoteActivities: boolean;
+    enableNexus: boolean;
+  };
   stickyQueueScheduleToStartTimeout: number;
   maxCachedWorkflows: number;
   maxHeartbeatThrottleInterval: number;
   defaultHeartbeatThrottleInterval: number;
   maxTaskQueueActivitiesPerSecond: Option<number>;
   maxActivitiesPerSecond: Option<number>;
   shutdownGraceTime: number;
+  plugins: string[];
 }
 
 export type PollerBehavior =

packages/core-bridge/ts/native.ts

@@ -298,14 +298,20 @@ const GenericConfigs = {
         initial: 5,
         maximum: 100,
       },
-      enableNonLocalActivities: false,
+      taskTypes: {
+        enableWorkflows: true,
+        enableLocalActivities: false,
+        enableRemoteActivities: false,
+        enableNexus: false,
+      },
       stickyQueueScheduleToStartTimeout: 1000,
       maxCachedWorkflows: 1000,
       maxHeartbeatThrottleInterval: 1000,
       defaultHeartbeatThrottleInterval: 1000,
       maxTaskQueueActivitiesPerSecond: null,
       maxActivitiesPerSecond: null,
       shutdownGraceTime: 1000,
+      plugins: [],
     } satisfies native.WorkerOptions,
   },
   ephemeralServer: {

packages/test/src/test-bridge.ts

@@ -657,3 +657,24 @@ test.serial('retryPolicy is set correctly', async (t) => {
     t.deepEqual(await executeWorkflow(getRetryPolicyFromActivityInfo, { args: [retryPolicy, false] }), retryPolicy);
   });
 });
+
+export async function runLocalActivityWithNonLocalActivitiesDisabled(): Promise<string> {
+  const { echo } = workflow.proxyLocalActivities({ startToCloseTimeout: '1m' });
+  return await echo('hello from local activity');
+}
+
+test.serial('Local activities work when enableNonLocalActivities is false', async (t) => {
+  const { executeWorkflow, createWorker } = helpers(t);
+  const worker = await createWorker({
+    activities: {
+      async echo(message: string): Promise<string> {
+        return message;
+      },
+    },
+    enableNonLocalActivities: false,
+  });
+  await worker.runUntil(async () => {
+    const result = await executeWorkflow(runLocalActivityWithNonLocalActivitiesDisabled);
+    t.is(result, 'hello from local activity');
+  });
+});

packages/test/src/test-local-activities.ts

@@ -1090,14 +1090,20 @@ export function toNativeWorkerOptions(opts: CompiledWorkerOptionsWithBuildId): n
     workflowTaskPollerBehavior: toNativeTaskPollerBehavior(opts.workflowTaskPollerBehavior),
     activityTaskPollerBehavior: toNativeTaskPollerBehavior(opts.activityTaskPollerBehavior),
     nexusTaskPollerBehavior: toNativeTaskPollerBehavior(opts.nexusTaskPollerBehavior),
-    enableNonLocalActivities: opts.enableNonLocalActivities,
+    taskTypes: {
+      enableWorkflows: opts.workflowBundle !== undefined || opts.workflowsPath !== undefined,
+      enableLocalActivities: opts.maxCachedWorkflows > 0 && opts.activities.size > 0,
+      enableRemoteActivities: opts.enableNonLocalActivities && opts.activities.size > 0,
+      enableNexus: opts.nexusServiceRegistry !== undefined,
+    },
     stickyQueueScheduleToStartTimeout: msToNumber(opts.stickyQueueScheduleToStartTimeout),
     maxCachedWorkflows: opts.maxCachedWorkflows,
     maxHeartbeatThrottleInterval: msToNumber(opts.maxHeartbeatThrottleInterval),
     defaultHeartbeatThrottleInterval: msToNumber(opts.defaultHeartbeatThrottleInterval),
     maxTaskQueueActivitiesPerSecond: opts.maxTaskQueueActivitiesPerSecond ?? null,
     maxActivitiesPerSecond: opts.maxActivitiesPerSecond ?? null,
     shutdownGraceTime: msToNumber(opts.shutdownGraceTime),
+    plugins: opts.plugins?.map((p) => p.name) ?? [],
   };
 }