@temporalio/core-bridge 1.13.0 → 1.13.2

package/sdk-core/tests/runner.rs

@@ -1,19 +1,24 @@
+// All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
+#[allow(dead_code)]
+mod common;
+
+use crate::common::integ_dev_server_config;
 use anyhow::{anyhow, bail};
 use clap::Parser;
+use common::INTEG_SERVER_TARGET_ENV_VAR;
 use std::{
     env,
     path::{Path, PathBuf},
     process::Stdio,
 };
-use temporal_sdk_core::ephemeral_server::{
-    EphemeralExe, EphemeralExeVersion, TemporalDevServerConfigBuilder, TestServerConfigBuilder,
-};
-use temporal_sdk_core_test_utils::{
-    INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR,
-    INTEG_TEST_SERVER_USED_ENV_VAR, SEARCH_ATTR_INT, SEARCH_ATTR_TXT, default_cached_download,
-};
+use temporal_sdk_core::ephemeral_server::{TestServerConfigBuilder, default_cached_download};
 use tokio::{self, process::Command};
 
+/// This env var is set (to any value) if temporal CLI dev server is in use
+const INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR: &str = "INTEG_TEMPORAL_DEV_SERVER_ON";
+/// This env var is set (to any value) if the test server is in use
+const INTEG_TEST_SERVER_USED_ENV_VAR: &str = "INTEG_TEST_SERVER_ON";
+
 #[derive(clap::Parser)]
 #[command(author, version, about, long_about = None)]
 struct Cli {
@@ -58,10 +63,15 @@ async fn main() -> Result<(), anyhow::Error> {
     } = Cli::parse();
     let cargo = env::var("CARGO").unwrap_or_else(|_| "cargo".to_string());
     // Try building first, so that we error early on build failures & don't start server
+    // Unclear why --all-features doesn't work here
     let test_args_preamble = [
         "test",
         "--features",
         "temporal-sdk-core-protos/serde_serialize",
+        "--features",
+        "test-utilities",
+        "--features",
+        "ephemeral-server",
         "--test",
         &test_name,
     ]
@@ -84,39 +94,11 @@ async fn main() -> Result<(), anyhow::Error> {
 
     let (server, envs) = match server_kind {
         ServerKind::TemporalCLI => {
-            let cli_version = if let Some(ver_override) = option_env!("CLI_VERSION_OVERRIDE") {
-                EphemeralExe::CachedDownload {
-                    version: EphemeralExeVersion::Fixed(ver_override.to_owned()),
-                    dest_dir: None,
-                    ttl: None,
-                }
-            } else {
-                default_cached_download()
-            };
-            let config = TemporalDevServerConfigBuilder::default()
-                .exe(cli_version)
-                .extra_args(vec![
-                    // TODO: Delete when temporalCLI enables it by default.
-                    "--dynamic-config-value".to_string(),
-                    "system.enableEagerWorkflowStart=true".to_string(),
-                    "--dynamic-config-value".to_string(),
-                    "system.enableNexus=true".to_string(),
-                    "--dynamic-config-value".to_owned(),
-                    "frontend.workerVersioningWorkflowAPIs=true".to_owned(),
-                    "--dynamic-config-value".to_owned(),
-                    "frontend.workerVersioningDataAPIs=true".to_owned(),
-                    "--dynamic-config-value".to_owned(),
-                    "system.enableDeploymentVersions=true".to_owned(),
-                    "--http-port".to_string(),
-                    "7243".to_string(),
-                    "--search-attribute".to_string(),
-                    format!("{SEARCH_ATTR_TXT}=Text"),
-                    "--search-attribute".to_string(),
-                    format!("{SEARCH_ATTR_INT}=Int"),
-                ])
-                .ui(true)
-                .build()?;
-            println!("Using temporal CLI: {:?}", config);
+            let config =
+                integ_dev_server_config(vec!["--http-port".to_string(), "7243".to_string()])
+                    .ui(true)
+                    .build()?;
+            println!("Using temporal CLI: {config:?}");
             (
                 Some(
                     config

package/sdk-core/tests/shared_tests/mod.rs

@@ -1,12 +1,12 @@
 //! Shared tests that are meant to be run against both local dev server and cloud
 
+use crate::common::CoreWfStarter;
 use std::sync::atomic::{AtomicBool, Ordering::Relaxed};
 use temporal_sdk::WfContext;
 use temporal_sdk_core_protos::temporal::api::{
     enums::v1::{EventType, WorkflowTaskFailedCause::GrpcMessageTooLarge},
     history::v1::history_event::Attributes::WorkflowTaskFailedEventAttributes,
 };
-use temporal_sdk_core_test_utils::CoreWfStarter;
 
 pub(crate) mod priority;
 

package/sdk-core/tests/shared_tests/priority.rs

@@ -1,3 +1,4 @@
+use crate::common::CoreWfStarter;
 use std::time::Duration;
 use temporal_client::{
     GetWorkflowResultOpts, Priority, WfClientExt, WorkflowClientTrait, WorkflowOptions,
@@ -7,7 +8,6 @@ use temporal_sdk_core_protos::{
     coresdk::AsJsonPayloadExt,
     temporal::api::{common, history::v1::history_event::Attributes},
 };
-use temporal_sdk_core_test_utils::CoreWfStarter;
 
 pub(crate) async fn priority_values_sent_to_server() {
     let mut starter = if let Some(wfs) =

package/sdk-core/{core/benches/workflow_replay.rs → tests/workflow_replay_bench.rs}

@@ -1,3 +1,11 @@
+//! This bench lives outside of the traditional /benches directory so it can share common code with
+//! integration tests.
+
+// All non-main.rs tests ignore dead common code so that the linter doesn't complain about about it.
+#[allow(dead_code)]
+mod common;
+
+use crate::common::{DONT_AUTO_INIT_INTEG_TELEM, prom_metrics, replay_sdk_worker};
 use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
 use futures_util::StreamExt;
 use std::{
@@ -10,10 +18,7 @@ use temporal_sdk_core::{CoreRuntime, replay::HistoryForReplay};
 use temporal_sdk_core_api::telemetry::metrics::{
     MetricKeyValue, MetricParametersBuilder, NewAttributes,
 };
-use temporal_sdk_core_protos::DEFAULT_WORKFLOW_TYPE;
-use temporal_sdk_core_test_utils::{
-    DONT_AUTO_INIT_INTEG_TELEM, canned_histories, prom_metrics, replay_sdk_worker,
-};
+use temporal_sdk_core_protos::{DEFAULT_WORKFLOW_TYPE, canned_histories};
 
 pub fn criterion_benchmark(c: &mut Criterion) {
     let tokio_runtime = tokio::runtime::Builder::new_current_thread()
@@ -73,7 +78,7 @@ pub fn bench_metrics(c: &mut Criterion) {
         .build()
         .unwrap();
     let _tokio = tokio_runtime.enter();
-    let (mut telemopts, addr, _aborter) = prom_metrics(None);
+    let (mut telemopts, _addr, _aborter) = prom_metrics(None);
     telemopts.logging = None;
     let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
     let meter = rt.telemetry().get_metric_meter().unwrap();

package/src/client.rs

@@ -3,12 +3,12 @@ use std::time::Duration;
 use std::{collections::HashMap, sync::Arc};
 
 use neon::prelude::*;
-use tonic::metadata::MetadataKey;
+use tonic::metadata::{BinaryMetadataValue, MetadataKey};
 
 use temporal_sdk_core::{ClientOptions as CoreClientOptions, CoreRuntime, RetryClient};
 
 use bridge_macros::{TryFromJs, js_function};
-use temporal_client::{ClientInitError, ConfiguredClient, TemporalServiceClientWithMetrics};
+use temporal_client::{ClientInitError, ConfiguredClient, TemporalServiceClient};
 
 use crate::runtime::Runtime;
 use crate::{helpers::*, runtime::RuntimeExt as _};
@@ -38,7 +38,7 @@ pub fn init(cx: &mut neon::prelude::ModuleContext) -> neon::prelude::NeonResult<
     Ok(())
 }
 
-type CoreClient = RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>;
+type CoreClient = RetryClient<ConfiguredClient<TemporalServiceClient>>;
 
 pub struct Client {
     // These fields are pub because they are accessed from Worker::new
@@ -61,6 +61,10 @@ pub fn client_new(
 
         let core_client = match res {
             Ok(core_client) => core_client,
+            Err(ClientInitError::InvalidHeaders(e)) => Err(BridgeError::TypeError {
+                message: format!("Invalid metadata key: {e}"),
+                field: None,
+            })?,
             Err(ClientInitError::SystemInfoCallError(e)) => Err(BridgeError::TransportError(
                 format!("Failed to call GetSystemInfo: {e}"),
             ))?,
@@ -84,13 +88,27 @@ pub fn client_new(
 #[js_function]
 pub fn client_update_headers(
     client: OpaqueInboundHandle<Client>,
-    headers: HashMap<String, String>,
+    headers: HashMap<String, MetadataValue>,
 ) -> BridgeResult<()> {
+    let (ascii_headers, bin_headers) = config::partition_headers(Some(headers));
+    client
+        .borrow()?
+        .core_client
+        .get_client()
+        .set_headers(ascii_headers.unwrap_or_default())
+        .map_err(|err| BridgeError::TypeError {
+            message: format!("Invalid metadata key: {err}"),
+            field: None,
+        })?;
     client
         .borrow()?
         .core_client
         .get_client()
-        .set_headers(headers);
+        .set_binary_headers(bin_headers.unwrap_or_default())
+        .map_err(|err| BridgeError::TypeError {
+            message: format!("Invalid metadata key: {err}"),
+            field: None,
+        })?;
     Ok(())
 }
 
@@ -122,10 +140,16 @@ pub struct RpcCall {
     pub rpc: String,
     pub req: Vec<u8>,
     pub retry: bool,
-    pub metadata: HashMap<String, String>,
+    pub metadata: HashMap<String, MetadataValue>,
     pub timeout: Option<Duration>,
 }
 
+#[derive(Debug, Clone, TryFromJs)]
+pub enum MetadataValue {
+    Ascii { value: String },
+    Binary { value: Vec<u8> },
+}
+
 /// Send a request to the Workflow Service using the provided Client
 #[js_function]
 pub fn client_send_workflow_service_request(
@@ -226,6 +250,8 @@ macro_rules! rpc_call {
 }
 
 // FIXME: "this function may allocate 1400106 bytes on the stack"
+#[allow(clippy::cognitive_complexity)]
+#[allow(clippy::large_stack_frames)]
 #[allow(clippy::too_many_lines)]
 async fn client_invoke_workflow_service(
     mut retry_client: CoreClient,
@@ -264,6 +290,9 @@ async fn client_invoke_workflow_service(
         "DescribeDeployment" => {
             rpc_call!(retry_client, call, describe_deployment)
         }
+        "DescribeWorker" => {
+            rpc_call!(retry_client, call, describe_worker)
+        }
         "DeprecateNamespace" => rpc_call!(retry_client, call, deprecate_namespace),
         "DescribeNamespace" => rpc_call!(retry_client, call, describe_namespace),
         "DescribeSchedule" => rpc_call!(retry_client, call, describe_schedule),
@@ -424,6 +453,9 @@ async fn client_invoke_workflow_service(
         "SetWorkerDeploymentCurrentVersion" => {
             rpc_call!(retry_client, call, set_worker_deployment_current_version)
         }
+        "SetWorkerDeploymentManager" => {
+            rpc_call!(retry_client, call, set_worker_deployment_manager)
+        }
         "SetWorkerDeploymentRampingVersion" => {
             rpc_call!(retry_client, call, set_worker_deployment_ramping_version)
         }
@@ -491,6 +523,7 @@ async fn client_invoke_workflow_service(
     }
 }
 
+#[allow(clippy::cognitive_complexity)]
 async fn client_invoke_operator_service(
     mut retry_client: CoreClient,
     call: RpcCall,
@@ -576,16 +609,29 @@ fn rpc_req<P: prost::Message + Default>(call: RpcCall) -> BridgeResult<tonic::Re
 
     let mut req = tonic::Request::new(proto);
     for (k, v) in call.metadata {
-        req.metadata_mut().insert(
-            MetadataKey::from_str(k.as_str()).map_err(|err| BridgeError::TypeError {
-                field: None,
-                message: format!("Invalid metadata key: {err}"),
-            })?,
-            v.parse().map_err(|err| BridgeError::TypeError {
-                field: None,
-                message: format!("Invalid metadata value: {err}"),
-            })?,
-        );
+        match v {
+            MetadataValue::Ascii { value: v } => {
+                req.metadata_mut().insert(
+                    MetadataKey::from_str(k.as_str()).map_err(|err| BridgeError::TypeError {
+                        field: None,
+                        message: format!("Invalid metadata key: {err}"),
+                    })?,
+                    v.parse().map_err(|err| BridgeError::TypeError {
+                        field: None,
+                        message: format!("Invalid metadata value: {err}"),
+                    })?,
+                );
+            }
+            MetadataValue::Binary { value: v } => {
+                req.metadata_mut().insert_bin(
+                    MetadataKey::from_str(k.as_str()).map_err(|err| BridgeError::TypeError {
+                        field: None,
+                        message: format!("Invalid metadata key: {err}"),
+                    })?,
+                    BinaryMetadataValue::from_bytes(&v),
+                );
+            }
+        }
     }
 
     if let Some(timeout) = call.timeout {
@@ -601,7 +647,7 @@ where
 {
     match res {
         Ok(resp) => Ok(resp.get_ref().encode_to_vec()),
-        Err(err) => Err(BridgeError::ServiceError(err)),
+        Err(err) => Err(BridgeError::from(err)),
     }
 }
 
@@ -620,7 +666,7 @@ mod config {
 
     use bridge_macros::TryFromJs;
 
-    use crate::helpers::*;
+    use crate::{client::MetadataValue, helpers::*};
 
     #[derive(Debug, Clone, TryFromJs)]
     pub(super) struct ClientOptions {
@@ -629,7 +675,7 @@ mod config {
         client_version: String,
         tls: Option<TlsConfig>,
         http_connect_proxy: Option<HttpConnectProxy>,
-        headers: Option<HashMap<String, String>>,
+        headers: Option<HashMap<String, MetadataValue>>,
         api_key: Option<String>,
         disable_error_code_metric_tags: bool,
     }
@@ -669,13 +715,16 @@ mod config {
                 builder.tls_cfg(tls.into());
             }
 
+            let (ascii_headers, bin_headers) = partition_headers(self.headers);
+
             let client_options = 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(self.headers)
+                .headers(ascii_headers)
+                .binary_headers(bin_headers)
                 .api_key(self.api_key)
                 .disable_error_code_metric_tags(self.disable_error_code_metric_tags)
                 // identity -- skipped: will be set on worker
@@ -711,4 +760,32 @@ mod config {
             }
         }
     }
+
+    #[allow(clippy::type_complexity)]
+    pub(super) fn partition_headers(
+        headers: Option<HashMap<String, MetadataValue>>,
+    ) -> (
+        Option<HashMap<String, String>>,
+        Option<HashMap<String, Vec<u8>>>,
+    ) {
+        let Some(headers) = headers else {
+            return (None, None);
+        };
+        let mut ascii_headers = HashMap::default();
+        let mut bin_headers = HashMap::default();
+        for (k, v) in headers {
+            match v {
+                MetadataValue::Ascii { value: v } => {
+                    ascii_headers.insert(k, v);
+                }
+                MetadataValue::Binary { value: v } => {
+                    bin_headers.insert(k, v);
+                }
+            }
+        }
+        (
+            (!ascii_headers.is_empty()).then_some(ascii_headers),
+            (!bin_headers.is_empty()).then_some(bin_headers),
+        )
+    }
 }

package/src/helpers/callbacks.rs

@@ -223,10 +223,10 @@ where
 
 impl<Args: TryIntoJsArgs + Send + Sync, Ret: TryFromJs + Send + Sync> CallbackInner<Args, Ret> {
     fn call<'a, C: Context<'a>>(&self, cx: &mut C, args: Args) -> BridgeResult<Ret> {
-        let this: Handle<'a, JsValue> = self
-            .this
-            .as_ref()
-            .map_or(cx.undefined().upcast(), |t| t.to_inner(cx).upcast());
+        let this: Handle<'a, JsValue> = match self.this.as_ref() {
+            Some(t) => t.to_inner(cx).upcast(),
+            None => cx.undefined().upcast(),
+        };
 
         // Convert the arguments to a JS array using the new trait
         let js_args = args.try_into_js_args(cx)?;

package/src/helpers/errors.rs

@@ -75,7 +75,7 @@ pub enum BridgeError {
     ///
     /// Becomes a JS `ServiceError` (adhering to the same interface as `grpc.ServiceError`).
     #[error(transparent)]
-    ServiceError(#[from] tonic::Status),
+    ServiceError(Box<tonic::Status>),
 
     /// Generic wrapper for other errors.
     ///
@@ -99,6 +99,12 @@ pub enum BridgeError {
     JsThrow { thrown: RefCell<Option<ThrowBox>> },
 }
 
+impl From<tonic::Status> for BridgeError {
+    fn from(value: tonic::Status) -> Self {
+        Self::ServiceError(Box::new(value))
+    }
+}
+
 // Append Field Context ////////////////////////////////////////////////////////////////////////////
 
 pub trait AppendFieldContext {

package/src/helpers/handles.rs

@@ -9,6 +9,7 @@ use parking_lot::Mutex;
 
 use super::{BridgeError, BridgeResult, IntoThrow, TryFromJs, TryIntoJs};
 
+#[allow(clippy::doc_overindented_list_items)]
 /// Opaque Handles are native structures that are sent into the JS side but without exposing
 /// their internal structure; i.e. they are only meant to be passed back to the Rust side
 /// on appropriate API calls.

package/src/helpers/try_from_js.rs

@@ -11,7 +11,7 @@ use neon::{
 };
 use temporal_sdk_core::Url;
 
-use super::{BridgeError, BridgeResult};
+use super::{AppendFieldContext, BridgeError, BridgeResult};
 
 /// Trait for Rust types that can be created from JavaScript values, possibly throwing an error.
 pub trait TryFromJs: Sized {
@@ -175,8 +175,9 @@ impl<T: TryFromJs> TryFromJs for HashMap<String, T> {
         let mut map = Self::new();
         for key_handle in props {
             let key = key_handle.to_string(cx)?.value(cx);
-            let value = obj.get_value(cx, key_handle)?;
-            map.insert(key, T::try_from_js(cx, value)?);
+            let js_value = obj.get_value(cx, key_handle)?;
+            let value = T::try_from_js(cx, js_value).field(&key)?;
+            map.insert(key, value);
         }
         Ok(map)
     }

package/src/lib.rs

@@ -1,4 +1,4 @@
-#![warn(
+#![deny(
     clippy::pedantic,
     clippy::nursery,
     clippy::cargo,
@@ -10,7 +10,8 @@
     clippy::too_long_first_doc_paragraph,
     clippy::option_if_let_else,
     clippy::multiple_crate_versions,
-    clippy::significant_drop_tightening
+    clippy::significant_drop_tightening,
+    clippy::upper_case_acronyms
 )]
 
 pub mod helpers;

package/src/metrics.rs

@@ -235,7 +235,10 @@ pub fn new_metric_gauge_f64(
     Ok(OpaqueOutboundHandle::new(GaugeF64 { meter, gauge }))
 }
 
+// We do not need to worry about losing the sign of `value` as JS verifies this is positive
+// It is understood that if passing in a float to a counter the value will be truncated
 #[js_function]
+#[allow(clippy::cast_sign_loss, clippy::cast_possible_truncation)]
 pub fn add_metric_counter_value(
     counter_handle: OpaqueInboundHandle<Counter>,
     value: f64,

package/src/runtime.rs

@@ -62,8 +62,11 @@ pub fn runtime_new(
     let (telemetry_options, metrics_options, logging_options) = 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 mut core_runtime = CoreRuntime::new(
+        telemetry_options,
+        TokioRuntimeBuilder::default(),
+    )
+    .context("Failed to initialize Core Runtime")?;
 
     enter_sync!(core_runtime);
 

package/src/worker.rs

@@ -296,7 +296,7 @@ pub fn worker_complete_nexus_task(
             .complete_nexus_task(nexus_completion)
             .await
             .map_err(|err| match err {
-                CompleteNexusError::NexusNotEnabled {} => {
+                CompleteNexusError::NexusNotEnabled => {
                     BridgeError::UnexpectedError(format!("{err}"))
                 }
                 CompleteNexusError::MalformedNexusCompletion { reason } => BridgeError::TypeError {
@@ -309,7 +309,7 @@ pub fn worker_complete_nexus_task(
 
 /// Request shutdown of the worker.
 /// Once complete Core will stop polling on new tasks and activations on worker's task queue.
-/// Caller should drain any pending tasks and activations and call worker_finalize_shutdown before breaking from
+/// Caller should drain any pending tasks and activations and call `worker_finalize_shutdown` before breaking from
 /// the loop to ensure graceful shutdown.
 #[js_function]
 pub fn worker_initiate_shutdown(worker: OpaqueInboundHandle<Worker>) -> BridgeResult<()> {
@@ -672,10 +672,8 @@ mod config {
                 self.local_activity_task_slot_supplier
                     .into_slot_supplier(&mut rbo),
             );
-            tuner_holder.nexus_slot_options(
-                self.nexus_task_slot_supplier
-                    .into_slot_supplier(&mut rbo)
-            );
+            tuner_holder
+                .nexus_slot_options(self.nexus_task_slot_supplier.into_slot_supplier(&mut rbo));
             if let Some(rbo) = rbo {
                 tuner_holder.resource_based_options(rbo);
             }
@@ -819,7 +817,6 @@ mod custom_slot_supplier {
                     Err(err) => {
                         warn!("Error reserving slot: {err:?}");
                         tokio::time::sleep(std::time::Duration::from_millis(1000)).await;
-                        continue;
                     }
                 }
             }
@@ -943,18 +940,18 @@ mod custom_slot_supplier {
         fn from(info: &'a CoreSlotInfo<'a>) -> Self {
             match info {
                 CoreSlotInfo::Workflow(info) => Self::Workflow {
-                    workflow_type: info.workflow_type.to_string(),
+                    workflow_type: info.workflow_type.clone(),
                     is_sticky: info.is_sticky,
                 },
                 CoreSlotInfo::Activity(info) => Self::Activity {
-                    activity_type: info.activity_type.to_string(),
+                    activity_type: info.activity_type.clone(),
                 },
                 CoreSlotInfo::LocalActivity(info) => Self::LocalActivity {
-                    activity_type: info.activity_type.to_string(),
+                    activity_type: info.activity_type.clone(),
                 },
                 CoreSlotInfo::Nexus(info) => Self::Nexus {
-                    service: info.service.to_string(),
-                    operation: info.operation.to_string(),
+                    service: info.service.clone(),
+                    operation: info.operation.clone(),
                 },
             }
         }

package/ts/native.ts

@@ -100,7 +100,7 @@ export interface OtelMetricsExporterOptions {
 
 export declare function newClient(runtime: Runtime, clientOptions: ClientOptions): Promise<Client>;
 
-export declare function clientUpdateHeaders(client: Client, headers: Record<string, string>): void;
+export declare function clientUpdateHeaders(client: Client, headers: Record<string, MetadataValue>): void;
 
 export declare function clientUpdateApiKey(client: Client, apiKey: string): void;
 
@@ -124,7 +124,7 @@ export interface ClientOptions {
   clientVersion: string;
   tls: Option<TLSConfig>;
   httpConnectProxy: Option<HttpConnectProxy>;
-  headers: Option<Record<string, string>>;
+  headers: Option<Record<string, MetadataValue>>;
   apiKey: Option<string>;
   disableErrorCodeMetricTags: boolean;
 }
@@ -157,7 +157,7 @@ export interface RpcCall {
   rpc: string;
   req: Buffer;
   retry: boolean;
-  metadata: Record<string, string>;
+  metadata: Record<string, MetadataValue>;
   timeout: Option<number>;
 }
 
@@ -191,6 +191,16 @@ export interface Worker {
   type: 'worker';
 }
 
+export type MetadataValue =
+  | {
+      type: 'ascii';
+      value: string;
+    }
+  | {
+      type: 'binary';
+      value: Buffer;
+    };
+
 export interface WorkerOptions {
   identity: string;
   buildId: string;