@temporalio/core-bridge 1.13.2 → 1.14.0

package/src/client.rs

@@ -5,10 +5,10 @@ use std::{collections::HashMap, sync::Arc};
 use neon::prelude::*;
 use tonic::metadata::{BinaryMetadataValue, MetadataKey};
 
-use temporal_sdk_core::{ClientOptions as CoreClientOptions, CoreRuntime, RetryClient};
+use temporalio_sdk_core::{ClientOptions as CoreClientOptions, CoreRuntime, RetryClient};
 
 use bridge_macros::{TryFromJs, js_function};
-use temporal_client::{ClientInitError, ConfiguredClient, TemporalServiceClient};
+use temporalio_client::{ClientInitError, ConfiguredClient, TemporalServiceClient};
 
 use crate::runtime::Runtime;
 use crate::{helpers::*, runtime::RuntimeExt as _};
@@ -257,7 +257,7 @@ async fn client_invoke_workflow_service(
     mut retry_client: CoreClient,
     call: RpcCall,
 ) -> BridgeResult<Vec<u8>> {
-    use temporal_client::WorkflowService;
+    use temporalio_client::WorkflowService;
 
     match call.rpc.as_str() {
         "CountWorkflowExecutions" => {
@@ -528,7 +528,7 @@ async fn client_invoke_operator_service(
     mut retry_client: CoreClient,
     call: RpcCall,
 ) -> BridgeResult<Vec<u8>> {
-    use temporal_client::OperatorService;
+    use temporalio_client::OperatorService;
 
     match call.rpc.as_str() {
         "AddOrUpdateRemoteCluster" => {
@@ -566,7 +566,7 @@ async fn client_invoke_test_service(
     mut retry_client: CoreClient,
     call: RpcCall,
 ) -> BridgeResult<Vec<u8>> {
-    use temporal_client::TestService;
+    use temporalio_client::TestService;
 
     match call.rpc.as_str() {
         "GetCurrentTime" => rpc_call!(retry_client, call, get_current_time),
@@ -588,7 +588,7 @@ async fn client_invoke_health_service(
     mut retry_client: CoreClient,
     call: RpcCall,
 ) -> BridgeResult<Vec<u8>> {
-    use temporal_client::HealthService;
+    use temporalio_client::HealthService;
 
     match call.rpc.as_str() {
         "Check" => rpc_call!(retry_client, call, check),
@@ -656,12 +656,10 @@ where
 mod config {
     use std::collections::HashMap;
 
-    use anyhow::Context as _;
-
-    use temporal_client::HttpConnectProxyOptions;
-    use temporal_sdk_core::{
-        ClientOptions as CoreClientOptions, ClientOptionsBuilder,
-        ClientTlsConfig as CoreClientTlsConfig, TlsConfig as CoreTlsConfig, Url,
+    use temporalio_client::HttpConnectProxyOptions;
+    use temporalio_sdk_core::{
+        ClientOptions as CoreClientOptions, ClientTlsOptions as CoreClientTlsOptions,
+        TlsOptions as CoreTlsOptions, Url,
     };
 
     use bridge_macros::TryFromJs;
@@ -673,7 +671,7 @@ mod config {
         target_url: Url,
         client_name: String,
         client_version: String,
-        tls: Option<TlsConfig>,
+        tls: Option<TlsOptions>,
         http_connect_proxy: Option<HttpConnectProxy>,
         headers: Option<HashMap<String, MetadataValue>>,
         api_key: Option<String>,
@@ -682,14 +680,14 @@ mod config {
 
     #[derive(Debug, Clone, TryFromJs)]
     #[allow(clippy::struct_field_names)]
-    struct TlsConfig {
+    struct TlsOptions {
         domain: Option<String>,
         server_root_ca_cert: Option<Vec<u8>>,
-        client_tls_config: Option<TlsConfigClientCertPair>,
+        client_tls_options: Option<TlsOptionsClientCertPair>,
     }
 
     #[derive(Debug, Clone, TryFromJs)]
-    struct TlsConfigClientCertPair {
+    struct TlsOptionsClientCertPair {
         client_cert: Vec<u8>,
         client_private_key: Vec<u8>,
     }
@@ -709,42 +707,35 @@ mod config {
     impl TryInto<CoreClientOptions> for ClientOptions {
         type Error = BridgeError;
         fn try_into(self) -> Result<CoreClientOptions, Self::Error> {
-            let mut builder = ClientOptionsBuilder::default();
-
-            if let Some(tls) = self.tls {
-                builder.tls_cfg(tls.into());
-            }
-
             let (ascii_headers, bin_headers) = partition_headers(self.headers);
 
-            let client_options = builder
+            let client_options = CoreClientOptions::builder()
                 .target_url(self.target_url)
                 .client_name(self.client_name)
                 .client_version(self.client_version)
-                // tls_cfg -- above
-                .http_connect_proxy(self.http_connect_proxy.map(Into::into))
-                .headers(ascii_headers)
-                .binary_headers(bin_headers)
-                .api_key(self.api_key)
+                .maybe_tls_options(self.tls.map(Into::into))
+                .maybe_http_connect_proxy(self.http_connect_proxy.map(Into::into))
+                .maybe_headers(ascii_headers)
+                .maybe_binary_headers(bin_headers)
+                .maybe_api_key(self.api_key)
                 .disable_error_code_metric_tags(self.disable_error_code_metric_tags)
                 // identity -- skipped: will be set on worker
                 // retry_config -- skipped: worker overrides anyway
                 // override_origin -- skipped: will default to tls_cfg.domain
                 // keep_alive -- skipped: defaults to true; is there any reason to disable this?
                 // skip_get_system_info -- skipped: defaults to false; is there any reason to set this?
-                .build()
-                .context("Invalid Client options")?;
+                .build();
 
             Ok(client_options)
         }
     }
 
-    impl From<TlsConfig> for CoreTlsConfig {
-        fn from(val: TlsConfig) -> Self {
+    impl From<TlsOptions> for CoreTlsOptions {
+        fn from(val: TlsOptions) -> Self {
             Self {
                 domain: val.domain,
                 server_root_ca_cert: val.server_root_ca_cert,
-                client_tls_config: val.client_tls_config.map(|pair| CoreClientTlsConfig {
+                client_tls_options: val.client_tls_options.map(|pair| CoreClientTlsOptions {
                     client_cert: pair.client_cert,
                     client_private_key: pair.client_private_key,
                 }),

package/src/helpers/try_from_js.rs

@@ -9,7 +9,7 @@ use neon::{
         Value, buffer::TypedArray,
     },
 };
-use temporal_sdk_core::Url;
+use temporalio_sdk_core::Url;
 
 use super::{AppendFieldContext, BridgeError, BridgeResult};
 

package/src/logs.rs

@@ -6,7 +6,7 @@ use std::{
 use neon::prelude::*;
 
 use serde::{Serialize, ser::SerializeMap as _};
-use temporal_sdk_core::api::telemetry::CoreLog;
+use temporalio_common::telemetry::CoreLog;
 
 use bridge_macros::js_function;
 

package/src/metrics.rs

@@ -4,14 +4,14 @@ use anyhow::Context as _;
 use neon::prelude::*;
 use serde::Deserialize;
 
-use temporal_sdk_core::api::telemetry::metrics::{
+use temporalio_common::telemetry::metrics::{
     CoreMeter, Counter as CoreCounter, Gauge as CoreGauge, Histogram as CoreHistogram,
     MetricParametersBuilder, NewAttributes, TemporalMeter,
 };
-use temporal_sdk_core::api::telemetry::metrics::{
+use temporalio_common::telemetry::metrics::{
     GaugeF64 as CoreGaugeF64, HistogramF64 as CoreHistogramF64,
 };
-use temporal_sdk_core::api::telemetry::metrics::{
+use temporalio_common::telemetry::metrics::{
     MetricKeyValue as CoreMetricKeyValue, MetricValue as CoreMetricValue,
 };
 

package/src/runtime.rs

@@ -5,12 +5,12 @@ use futures::channel::mpsc::Receiver;
 use neon::prelude::*;
 use tracing::{Instrument, warn};
 
-use temporal_sdk_core::{
-    CoreRuntime, TokioRuntimeBuilder,
-    api::telemetry::{
-        CoreLog, OtelCollectorOptions as CoreOtelCollectorOptions,
-        PrometheusExporterOptions as CorePrometheusExporterOptions, metrics::CoreMeter,
-    },
+use temporalio_common::telemetry::{
+    CoreLog, OtelCollectorOptions as CoreOtelCollectorOptions,
+    PrometheusExporterOptions as CorePrometheusExporterOptions, metrics::CoreMeter,
+};
+use temporalio_sdk_core::{
+    CoreRuntime, RuntimeOptionsBuilder, TokioRuntimeBuilder,
     telemetry::{build_otlp_metric_exporter, start_prometheus_metric_exporter},
 };
 
@@ -59,14 +59,17 @@ pub struct Runtime {
 pub fn runtime_new(
     bridge_options: config::RuntimeOptions,
 ) -> BridgeResult<OpaqueOutboundHandle<Runtime>> {
-    let (telemetry_options, metrics_options, logging_options) = bridge_options.try_into()?;
+    let (telemetry_options, metrics_options, logging_options, worker_heartbeat_interval_millis) =
+        bridge_options.try_into()?;
 
     // Create core runtime which starts tokio multi-thread runtime
-    let mut core_runtime = CoreRuntime::new(
-        telemetry_options,
-        TokioRuntimeBuilder::default(),
-    )
-    .context("Failed to initialize Core Runtime")?;
+    let runtime_options = RuntimeOptionsBuilder::default()
+        .telemetry_options(telemetry_options)
+        .heartbeat_interval(worker_heartbeat_interval_millis.map(Duration::from_millis))
+        .build()
+        .context("Failed to build runtime options")?;
+    let mut core_runtime = CoreRuntime::new(runtime_options, TokioRuntimeBuilder::default())
+        .context("Failed to initialize Core Runtime")?;
 
     enter_sync!(core_runtime);
 
@@ -238,17 +241,14 @@ mod config {
     use anyhow::Context as _;
 
     use neon::prelude::*;
-    use temporal_sdk_core::{
-        Url,
-        api::telemetry::{
-            HistogramBucketOverrides, Logger as CoreTelemetryLogger, MetricTemporality,
-            OtelCollectorOptions as CoreOtelCollectorOptions, OtelCollectorOptionsBuilder,
-            OtlpProtocol, PrometheusExporterOptions as CorePrometheusExporterOptions,
-            PrometheusExporterOptionsBuilder, TelemetryOptions as CoreTelemetryOptions,
-            TelemetryOptionsBuilder,
-        },
-        telemetry::CoreLogStreamConsumer,
+    use temporalio_common::telemetry::{
+        HistogramBucketOverrides, Logger as CoreTelemetryLogger, MetricTemporality,
+        OtelCollectorOptions as CoreOtelCollectorOptions, OtelCollectorOptionsBuilder,
+        OtlpProtocol, PrometheusExporterOptions as CorePrometheusExporterOptions,
+        PrometheusExporterOptionsBuilder, TelemetryOptions as CoreTelemetryOptions,
+        TelemetryOptionsBuilder,
     };
+    use temporalio_sdk_core::{Url, telemetry::CoreLogStreamConsumer};
 
     use bridge_macros::TryFromJs;
 
@@ -267,6 +267,7 @@ mod config {
         log_exporter: LogExporterOptions,
         telemetry: TelemetryOptions,
         metrics_exporter: Option<MetricsExporterOptions>,
+        worker_heartbeat_interval_millis: Option<u64>,
     }
 
     #[derive(Debug, Clone, TryFromJs)]
@@ -323,6 +324,7 @@ mod config {
             CoreTelemetryOptions,
             Option<super::BridgeMetricsExporter>,
             super::BridgeLogExporter,
+            Option<u64>,
         )> for RuntimeOptions
     {
         type Error = BridgeError;
@@ -332,8 +334,16 @@ mod config {
             CoreTelemetryOptions,
             Option<super::BridgeMetricsExporter>,
             super::BridgeLogExporter,
+            Option<u64>,
         )> {
-            let (telemetry_logger, log_exporter) = match self.log_exporter {
+            let Self {
+                log_exporter,
+                telemetry,
+                metrics_exporter,
+                worker_heartbeat_interval_millis,
+            } = self;
+
+            let (telemetry_logger, log_exporter) = match log_exporter {
                 LogExporterOptions::Console { filter } => (
                     CoreTelemetryLogger::Console { filter },
                     BridgeLogExporter::Console,
@@ -353,17 +363,21 @@ mod config {
             let mut telemetry_options = TelemetryOptionsBuilder::default();
             let telemetry_options = telemetry_options
                 .logging(telemetry_logger)
-                .metric_prefix(self.telemetry.metric_prefix)
-                .attach_service_name(self.telemetry.attach_service_name)
+                .metric_prefix(telemetry.metric_prefix)
+                .attach_service_name(telemetry.attach_service_name)
                 .build()
                 .context("Failed to build telemetry options")?;
 
-            let metrics_exporter = self
-                .metrics_exporter
+            let metrics_exporter = metrics_exporter
                 .map(std::convert::TryInto::try_into)
                 .transpose()?;
 
-            Ok((telemetry_options, metrics_exporter, log_exporter))
+            Ok((
+                telemetry_options,
+                metrics_exporter,
+                log_exporter,
+                worker_heartbeat_interval_millis,
+            ))
         }
     }
 

package/src/testing.rs

@@ -4,13 +4,13 @@ use std::{process::Stdio, sync::Arc};
 use anyhow::Context as _;
 use neon::prelude::*;
 
-use temporal_sdk_core::ephemeral_server::{
+use temporalio_sdk_core::ephemeral_server::{
     EphemeralServer as CoreEphemeralServer, TemporalDevServerConfig as CoreTemporalDevServerConfig,
     TestServerConfig as CoreTestServerConfig,
 };
 
 use bridge_macros::js_function;
-use temporal_sdk_core::CoreRuntime;
+use temporalio_sdk_core::CoreRuntime;
 
 use crate::helpers::*;
 use crate::runtime::{Runtime, RuntimeExt as _};
@@ -191,7 +191,7 @@ mod config {
 
     use anyhow::Context as _;
 
-    use temporal_sdk_core::ephemeral_server::{
+    use temporalio_sdk_core::ephemeral_server::{
         EphemeralExe, EphemeralExeVersion, TemporalDevServerConfig as CoreTemporalDevServerConfig,
         TemporalDevServerConfigBuilder, TestServerConfig as CoreTestServerConfig,
         TestServerConfigBuilder,

package/src/worker.rs

@@ -6,20 +6,19 @@ use prost::Message;
 use tokio::sync::mpsc::{Sender, channel};
 use tokio_stream::wrappers::ReceiverStream;
 
-use temporal_sdk_core::{
-    CoreRuntime,
-    api::{
-        Worker as CoreWorkerTrait,
-        errors::{CompleteActivityError, CompleteNexusError, CompleteWfError, PollError},
-    },
-    init_replay_worker, init_worker,
-    protos::{
-        coresdk::{
-            ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
-            workflow_completion::WorkflowActivationCompletion,
-        },
-        temporal::api::history::v1::History,
+use temporalio_common::Worker as CoreWorkerTrait;
+use temporalio_common::errors::{
+    CompleteActivityError, CompleteNexusError, CompleteWfError, PollError,
+};
+use temporalio_common::protos::{
+    coresdk::{
+        ActivityHeartbeat, ActivityTaskCompletion, nexus::NexusTaskCompletion,
+        workflow_completion::WorkflowActivationCompletion,
     },
+    temporal::api::history::v1::History,
+};
+use temporalio_sdk_core::{
+    CoreRuntime, init_replay_worker, init_worker,
     replay::{HistoryForReplay, ReplayWorkerInput},
 };
 
@@ -70,7 +69,7 @@ pub struct Worker {
     core_runtime: Arc<CoreRuntime>,
 
     // Arc so that we can send reference into async closures
-    core_worker: Arc<temporal_sdk_core::Worker>,
+    core_worker: Arc<temporalio_sdk_core::Worker>,
 }
 
 /// Create a new worker.
@@ -167,6 +166,9 @@ pub fn worker_complete_workflow_activation(
                         ),
                     }
                 }
+                CompleteWfError::WorkflowNotEnabled => {
+                    BridgeError::UnexpectedError(err.to_string())
+                }
             })
     })
 }
@@ -226,6 +228,9 @@ pub fn worker_complete_activity_task(
                     field: None,
                     message: format!("Malformed Activity Completion: {reason:?}"),
                 },
+                CompleteActivityError::ActivityNotEnabled => {
+                    BridgeError::UnexpectedError(err.to_string())
+                }
             })
     })
 }
@@ -297,7 +302,7 @@ pub fn worker_complete_nexus_task(
             .await
             .map_err(|err| match err {
                 CompleteNexusError::NexusNotEnabled => {
-                    BridgeError::UnexpectedError(format!("{err}"))
+                    BridgeError::UnexpectedError(err.to_string())
                 }
                 CompleteNexusError::MalformedNexusCompletion { reason } => BridgeError::TypeError {
                     field: None,
@@ -464,18 +469,19 @@ impl MutableFinalize for HistoryForReplayTunnelHandle {}
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 mod config {
+    use std::collections::HashSet;
     use std::{sync::Arc, time::Duration};
-
-    use temporal_sdk_core::{
+    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,
+        WorkerConfigBuilderError, WorkerDeploymentOptions as CoreWorkerDeploymentOptions,
+        WorkerDeploymentVersion as CoreWorkerDeploymentVersion, WorkflowSlotKind,
+    };
+    use temporalio_sdk_core::{
         ResourceBasedSlotsOptions, ResourceBasedSlotsOptionsBuilder, ResourceSlotOptions,
         SlotSupplierOptions as CoreSlotSupplierOptions, TunerHolder, TunerHolderOptionsBuilder,
-        api::worker::{
-            ActivitySlotKind, LocalActivitySlotKind, NexusSlotKind,
-            PollerBehavior as CorePollerBehavior, SlotKind, WorkerConfig, WorkerConfigBuilder,
-            WorkerConfigBuilderError, WorkerDeploymentOptions as CoreWorkerDeploymentOptions,
-            WorkerDeploymentVersion as CoreWorkerDeploymentVersion, WorkflowSlotKind,
-        },
-        protos::temporal::api::enums::v1::VersioningBehavior as CoreVersioningBehavior,
     };
 
     use super::custom_slot_supplier::CustomSlotSupplierOptions;
@@ -485,7 +491,7 @@ mod config {
     use neon::object::Object;
     use neon::prelude::JsResult;
     use neon::types::JsObject;
-    use temporal_sdk_core::api::worker::WorkerVersioningStrategy;
+    use temporalio_common::worker::WorkerVersioningStrategy;
 
     #[derive(TryFromJs)]
     pub struct BridgeWorkerOptions {
@@ -500,7 +506,7 @@ 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,
@@ -508,6 +514,7 @@ mod config {
         max_activities_per_second: Option<f64>,
         max_task_queue_activities_per_second: Option<f64>,
         shutdown_grace_time: Option<Duration>,
+        plugins: Vec<String>,
     }
 
     #[derive(TryFromJs)]
@@ -541,6 +548,26 @@ mod config {
         AutoUpgrade,
     }
 
+    #[derive(TryFromJs)]
+    #[allow(clippy::struct_excessive_bools)]
+    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
@@ -567,7 +594,7 @@ 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)
@@ -575,6 +602,15 @@ mod config {
                 .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::<HashSet<_>>(),
+                )
                 .build()
         }
     }
@@ -749,16 +785,14 @@ mod custom_slot_supplier {
 
     use neon::{context::Context, handle::Handle, prelude::*};
 
-    use temporal_sdk_core::{
-        SlotSupplierOptions as CoreSlotSupplierOptions,
-        api::worker::{
-            SlotInfo as CoreSlotInfo, SlotInfoTrait as _, SlotKind,
-            SlotKindType as CoreSlotKindType, SlotMarkUsedContext as CoreSlotMarkUsedContext,
-            SlotReleaseContext as CoreSlotReleaseContext,
-            SlotReservationContext as CoreSlotReservationContext, SlotSupplier as CoreSlotSupplier,
-            SlotSupplierPermit as CoreSlotSupplierPermit,
-        },
+    use temporalio_common::worker::{
+        SlotInfo as CoreSlotInfo, SlotInfoTrait as _, SlotKind, SlotKindType as CoreSlotKindType,
+        SlotMarkUsedContext as CoreSlotMarkUsedContext,
+        SlotReleaseContext as CoreSlotReleaseContext,
+        SlotReservationContext as CoreSlotReservationContext, SlotSupplier as CoreSlotSupplier,
+        SlotSupplierPermit as CoreSlotSupplierPermit,
     };
+    use temporalio_sdk_core::SlotSupplierOptions as CoreSlotSupplierOptions;
 
     use bridge_macros::{TryFromJs, TryIntoJs};
     use tracing::warn;

package/ts/native.ts

@@ -40,7 +40,7 @@ export type JsonString<_T> = string;
 // Runtime
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-export declare function newRuntime(telemOptions: RuntimeOptions): Runtime;
+export declare function newRuntime(runtimeOptions: RuntimeOptions): Runtime;
 
 export declare function runtimeShutdown(runtime: Runtime): void;
 
@@ -52,6 +52,7 @@ export type RuntimeOptions = {
   logExporter: LogExporterOptions;
   telemetry: TelemetryOptions;
   metricsExporter: MetricExporterOptions;
+  workerHeartbeatIntervalMillis: Option<number>;
 };
 
 export type TelemetryOptions = {
@@ -122,20 +123,20 @@ export interface ClientOptions {
   targetUrl: string;
   clientName: string;
   clientVersion: string;
-  tls: Option<TLSConfig>;
+  tls: Option<TlsOptions>;
   httpConnectProxy: Option<HttpConnectProxy>;
   headers: Option<Record<string, MetadataValue>>;
   apiKey: Option<string>;
   disableErrorCodeMetricTags: boolean;
 }
 
-export interface TLSConfig {
+export interface TlsOptions {
   domain: Option<string>;
   serverRootCaCert: Option<Buffer>;
-  clientTlsConfig: Option<TlsConfigClientCertPair>;
+  clientTlsOptions: Option<TlsOptionsClientCertPair>;
 }
 
-export interface TlsConfigClientCertPair {
+export interface TlsOptionsClientCertPair {
   clientCert: Buffer;
   clientPrivateKey: Buffer;
 }
@@ -213,7 +214,12 @@ 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;
@@ -221,6 +227,7 @@ export interface WorkerOptions {
   maxTaskQueueActivitiesPerSecond: Option<number>;
   maxActivitiesPerSecond: Option<number>;
   shutdownGraceTime: number;
+  plugins: string[];
 }
 
 export type PollerBehavior =

package/LICENSE.md

@@ -1,23 +0,0 @@
-Temporal TypeScript SDK
-
-MIT License
-
-Copyright (c) 2021 Temporal Technologies Inc. All Rights Reserved
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.