@temporalio/core-bridge 1.9.2 → 1.10.0

package/sdk-core/tests/integ_tests/workflow_tests/upsert_search_attrs.rs

@@ -24,7 +24,7 @@ async fn sends_upsert() {
     let wf_name = "sends_upsert_search_attrs";
     let wf_id = Uuid::new_v4();
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.no_remote_activities();
+    starter.worker_config.no_remote_activities(true);
     let mut worker = starter.worker().await;
     // TODO: this should be supported in server 1.20, remove this condition when CLI is upgraded.
     if env::var(INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR).is_ok() {

package/sdk-core/tests/integ_tests/workflow_tests.rs

@@ -16,11 +16,11 @@ mod stickyness;
 mod timers;
 mod upsert_search_attrs;
 
-use crate::integ_tests::activity_functions::echo;
+use crate::integ_tests::{activity_functions::echo, metrics_tests};
 use assert_matches::assert_matches;
 use futures::{channel::mpsc::UnboundedReceiver, future, SinkExt, StreamExt};
 use std::{
-    collections::HashMap,
+    collections::{HashMap, HashSet},
     sync::{
         atomic::{AtomicUsize, Ordering},
         Arc,
@@ -29,8 +29,11 @@ use std::{
 };
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{interceptors::WorkerInterceptor, ActivityOptions, WfContext, WorkflowResult};
-use temporal_sdk_core::replay::HistoryForReplay;
-use temporal_sdk_core_api::{errors::PollWfError, Worker};
+use temporal_sdk_core::{replay::HistoryForReplay, CoreRuntime};
+use temporal_sdk_core_api::{
+    errors::{PollWfError, WorkflowErrorType},
+    Worker,
+};
 use temporal_sdk_core_protos::{
     coresdk::{
         activity_result::ActivityExecutionResult,
@@ -41,7 +44,10 @@ use temporal_sdk_core_protos::{
         workflow_completion::WorkflowActivationCompletion,
         ActivityTaskCompletion, AsJsonPayloadExt, IntoCompletion,
     },
-    temporal::api::{failure::v1::Failure, history::v1::history_event, query::v1::WorkflowQuery},
+    temporal::api::{
+        enums::v1::EventType, failure::v1::Failure, history::v1::history_event,
+        query::v1::WorkflowQuery,
+    },
 };
 use temporal_sdk_core_test_utils::{
     drain_pollers_and_shutdown, history_from_proto_binary, init_core_and_create_wf,
@@ -109,7 +115,8 @@ async fn parallel_workflows_same_queue() {
 }
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
-pub async fn cache_evictions_wf(command_sink: WfContext) -> WorkflowResult<()> {
+
+pub(crate) async fn cache_evictions_wf(command_sink: WfContext) -> WorkflowResult<()> {
     RUN_CT.fetch_add(1, Ordering::SeqCst);
     command_sink.timer(Duration::from_secs(1)).await;
     Ok(().into())
@@ -119,7 +126,11 @@ pub async fn cache_evictions_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn workflow_lru_cache_evictions() {
     let wf_type = "workflow_lru_cache_evictions";
     let mut starter = CoreWfStarter::new(wf_type);
-    starter.no_remote_activities().max_cached_workflows(1);
+    starter
+        .worker_config
+        .max_concurrent_wft_polls(1_usize)
+        .no_remote_activities(true)
+        .max_cached_workflows(1_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_type.to_string(), cache_evictions_wf);
 
@@ -163,7 +174,7 @@ async fn shutdown_aborts_actively_blocked_poll() {
     // Begin the poll, and request shutdown from another thread after a small period of time.
     let tcore = core.clone();
     let handle = tokio::spawn(async move {
-        std::thread::sleep(Duration::from_millis(100));
+        tokio::time::sleep(Duration::from_millis(100)).await;
         drain_pollers_and_shutdown(&tcore).await;
     });
     assert_matches!(
@@ -434,9 +445,10 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
     let signal_at_complete = "at-complete";
     let mut wf_starter = CoreWfStarter::new("wft_timeout_doesnt_create_unsolvable_autocomplete");
     wf_starter
+        .worker_config
         // Test needs eviction on and a short timeout
-        .max_cached_workflows(0)
-        .max_wft(1);
+        .max_cached_workflows(0_usize)
+        .max_outstanding_workflow_tasks(1_usize);
     wf_starter.worker_config.max_concurrent_wft_polls(1_usize);
     wf_starter.workflow_options.task_timeout = Some(Duration::from_secs(1));
     let core = wf_starter.get_worker().await;
@@ -552,7 +564,10 @@ async fn wft_timeout_doesnt_create_unsolvable_autocomplete() {
 async fn slow_completes_with_small_cache() {
     let wf_name = "slow_completes_with_small_cache";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.max_wft(5).max_cached_workflows(5);
+    starter
+        .worker_config
+        .max_outstanding_workflow_tasks(5_usize)
+        .max_cached_workflows(5_usize);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), |ctx: WfContext| async move {
         for _ in 0..3 {
@@ -730,3 +745,92 @@ async fn build_id_correct_in_wf_info() {
     assert_eq!(res.build_id_for_current_task, "2.0");
     core.complete_execution(&res.run_id).await;
 }
+
+#[rstest::rstest]
+#[tokio::test]
+async fn nondeterminism_errors_fail_workflow_when_configured_to(
+    #[values(true, false)] whole_worker: bool,
+) {
+    let (telemopts, addr, _aborter) = metrics_tests::prom_metrics(false, false);
+    let rt = CoreRuntime::new_assume_tokio(telemopts).unwrap();
+    let wf_name = "nondeterminism_errors_fail_workflow_when_configured_to";
+    let mut starter = CoreWfStarter::new_with_runtime(wf_name, rt);
+    starter.worker_config.no_remote_activities(true);
+    let typeset = HashSet::from([WorkflowErrorType::Nondeterminism]);
+    if whole_worker {
+        starter.worker_config.workflow_failure_errors(typeset);
+    } else {
+        starter
+            .worker_config
+            .workflow_types_to_failure_errors(HashMap::from([(wf_name.to_owned(), typeset)]));
+    }
+    let wf_id = starter.get_task_queue().to_owned();
+    let mut worker = starter.worker().await;
+    worker.fetch_results = false;
+
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
+        ctx.timer(Duration::from_secs(1000)).await;
+        Ok(().into())
+    });
+    let client = starter.get_client().await;
+    let core_worker = worker.core_worker.clone();
+    starter.start_with_worker(wf_name, &mut worker).await;
+
+    let stopper = async {
+        // Wait for the timer to show up in history and then stop the worker
+        loop {
+            let hist = client
+                .get_workflow_execution_history(wf_id.clone(), None, vec![])
+                .await
+                .unwrap()
+                .history
+                .unwrap();
+            let has_timer_event = hist
+                .events
+                .iter()
+                .any(|e| matches!(e.event_type(), EventType::TimerStarted));
+            if has_timer_event {
+                break;
+            }
+            tokio::time::sleep(Duration::from_millis(100)).await;
+        }
+        core_worker.initiate_shutdown();
+    };
+    let runner = async {
+        worker.run_until_done().await.unwrap();
+    };
+    join!(stopper, runner);
+
+    // Restart the worker with a new, incompatible wf definition which will cause nondeterminism
+    let mut starter = starter.clone_no_worker();
+    let mut worker = starter.worker().await;
+    worker.register_wf(wf_name.to_owned(), move |ctx: WfContext| async move {
+        ctx.activity(ActivityOptions {
+            activity_type: "echo_activity".to_string(),
+            start_to_close_timeout: Some(Duration::from_secs(5)),
+            ..Default::default()
+        })
+        .await;
+        Ok(().into())
+    });
+    // We need to generate a task so that we'll encounter the error (first avoid WFT timeout)
+    client
+        .reset_sticky_task_queue(wf_id.clone(), "".to_string())
+        .await
+        .unwrap();
+    client
+        .signal_workflow_execution(wf_id.clone(), "".to_string(), "hi".to_string(), None, None)
+        .await
+        .unwrap();
+    worker.expect_workflow_completion(&wf_id, None);
+    // If we don't fail the workflow on nondeterminism, we'll get stuck here retrying the WFT
+    worker.run_until_done().await.unwrap();
+
+    let body = metrics_tests::get_text(format!("http://{addr}/metrics")).await;
+    let match_this = format!(
+        "temporal_workflow_failed{{namespace=\"default\",\
+         service_name=\"temporal-core-sdk\",\
+         task_queue=\"{wf_id}\",workflow_type=\"{wf_name}\"}} 1"
+    );
+    assert!(body.contains(&match_this));
+}

package/sdk-core/tests/main.rs

@@ -38,7 +38,7 @@ mod integ_tests {
         let opts = get_integ_server_options();
         let runtime = CoreRuntime::new_assume_tokio(get_integ_telem_options()).unwrap();
         let mut retrying_client = opts
-            .connect_no_namespace(runtime.telemetry().get_temporal_metric_meter(), None)
+            .connect_no_namespace(runtime.telemetry().get_temporal_metric_meter())
             .await
             .unwrap();
 
@@ -85,7 +85,7 @@ mod integ_tests {
             .build()
             .unwrap();
         let con = sgo
-            .connect("spencer.temporal-dev".to_string(), None, None)
+            .connect("spencer.temporal-dev".to_string(), None)
             .await
             .unwrap();
         dbg!(con

package/src/conversions.rs

@@ -6,6 +6,7 @@ use neon::{
     types::{JsBoolean, JsNumber, JsString},
 };
 use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
+use temporal_client::HttpConnectProxyOptions;
 use temporal_sdk_core::{
     api::telemetry::{Logger, MetricTemporality, TelemetryOptions, TelemetryOptionsBuilder},
     api::{
@@ -121,6 +122,26 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             }
         };
 
+        let proxy_cfg = match js_optional_getter!(cx, self, "proxy", JsObject) {
+            None => None,
+            Some(proxy) => {
+                let target_addr = js_value_getter!(cx, &proxy, "targetHost", JsString);
+
+                let basic_auth = match js_optional_getter!(cx, &proxy, "basicAuth", JsObject) {
+                    None => None,
+                    Some(proxy_obj) => Some((
+                        js_value_getter!(cx, &proxy_obj, "username", JsString),
+                        js_value_getter!(cx, &proxy_obj, "password", JsString),
+                    )),
+                };
+
+                Some(HttpConnectProxyOptions {
+                    target_addr,
+                    basic_auth,
+                })
+            }
+        };
+
         let retry_config = match js_optional_getter!(cx, self, "retry", JsObject) {
             None => RetryConfig::default(),
             Some(ref retry_config) => RetryConfig {
@@ -158,6 +179,20 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
         if let Some(tls_cfg) = tls_cfg {
             client_options.tls_cfg(tls_cfg);
         }
+        client_options.http_connect_proxy(proxy_cfg);
+        let headers = match js_optional_getter!(cx, self, "metadata", JsObject) {
+            None => None,
+            Some(h) => Some(h.as_hash_map_of_string_to_string(cx).map_err(|reason| {
+                cx.throw_type_error::<_, HashMap<String, String>>(format!(
+                    "Invalid metadata: {}",
+                    reason
+                ))
+                .unwrap_err()
+            })?),
+        };
+        client_options.headers(headers);
+        let api_key = js_optional_value_getter!(cx, self, "apiKey", JsString);
+        client_options.api_key(api_key);
 
         Ok(client_options
             .client_name("temporal-typescript".to_string())
@@ -211,6 +246,22 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                     }
                 };
 
+                if let Some(counters_total_suffix) =
+                    js_optional_value_getter!(cx, prom, "countersTotalSuffix", JsBoolean)
+                {
+                    options.counters_total_suffix(counters_total_suffix);
+                }
+                if let Some(unit_suffix) =
+                    js_optional_value_getter!(cx, prom, "unitSuffix", JsBoolean)
+                {
+                    options.unit_suffix(unit_suffix);
+                }
+                if let Some(use_seconds_for_durations) =
+                    js_optional_value_getter!(cx, prom, "useSecondsForDurations", JsBoolean)
+                {
+                    options.use_seconds_for_durations(use_seconds_for_durations);
+                }
+
                 let options = options.build().map_err(|e| {
                     cx.throw_type_error::<_, TelemetryOptions>(format!(
                         "Failed to build prometheus exporter options: {:?}",
@@ -240,6 +291,12 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                     }
                 };
 
+                if let Some(use_seconds_for_durations) =
+                    js_optional_value_getter!(cx, otel, "useSecondsForDurations", JsBoolean)
+                {
+                    options.use_seconds_for_durations(use_seconds_for_durations);
+                }
+
                 if let Some(ref headers) = js_optional_getter!(cx, otel, "headers", JsObject) {
                     options.headers(headers.as_hash_map_of_string_to_string(cx)?);
                 };

package/src/lib.rs

@@ -16,6 +16,7 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("newRuntime", runtime_new)?;
     cx.export_function("newClient", client_new)?;
     cx.export_function("clientUpdateHeaders", client_update_headers)?;
+    cx.export_function("clientUpdateApiKey", client_update_api_key)?;
     cx.export_function("newWorker", worker_new)?;
     cx.export_function("newReplayWorker", replay_worker_new)?;
     cx.export_function("pushHistory", push_history)?;

package/src/runtime.rs

@@ -1,28 +1,24 @@
 use crate::{conversions::*, errors::*, helpers::*, worker::*};
-use neon::context::Context;
-use neon::prelude::*;
-use parking_lot::RwLock;
-use std::cell::Cell;
+use neon::{context::Context, prelude::*};
 use std::{
-    cell::RefCell,
+    cell::{Cell, RefCell},
     collections::HashMap,
     ops::Deref,
+    process::Stdio,
     sync::Arc,
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 use temporal_client::{ClientInitError, ConfiguredClient, TemporalServiceClientWithMetrics};
-use temporal_sdk_core::api::telemetry::CoreTelemetry;
-use temporal_sdk_core::CoreRuntime;
 use temporal_sdk_core::{
+    api::telemetry::CoreTelemetry,
     ephemeral_server::EphemeralServer as CoreEphemeralServer,
     init_replay_worker, init_worker,
     replay::{HistoryForReplay, ReplayWorkerInput},
-    ClientOptions, RetryClient, WorkerConfig,
+    ClientOptions, CoreRuntime, RetryClient, WorkerConfig,
 };
-use tokio::sync::oneshot;
 use tokio::sync::{
     mpsc::{channel, unbounded_channel, Sender, UnboundedReceiver, UnboundedSender},
-    Mutex,
+    oneshot, Mutex,
 };
 use tokio_stream::wrappers::ReceiverStream;
 
@@ -64,7 +60,6 @@ pub enum RuntimeRequest {
     CreateClient {
         runtime: Arc<RuntimeHandle>,
         options: ClientOptions,
-        headers: Option<HashMap<String, String>>,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
@@ -111,6 +106,11 @@ pub enum RuntimeRequest {
         pushme: HistoryForReplay,
         callback: Root<JsFunction>,
     },
+    UpdateClientApiKey {
+        client: Arc<RawClient>,
+        key: String,
+        callback: Root<JsFunction>,
+    },
 }
 
 /// Builds a tokio runtime and starts polling on [RuntimeRequest]s via an internal channel.
@@ -166,13 +166,12 @@ pub fn start_bridge_loop(
                 RuntimeRequest::CreateClient {
                     runtime,
                     options,
-                    headers,
                     callback,
                 } => {
                     let mm = core_runtime.telemetry().get_metric_meter();
                     core_runtime.tokio_handle().spawn(async move {
                         match options
-                            .connect_no_namespace(mm, headers.map(|h| Arc::new(RwLock::new(h))))
+                            .connect_no_namespace(mm)
                             .await
                         {
                             Err(err) => {
@@ -211,6 +210,10 @@ pub fn start_bridge_loop(
                     client.get_client().set_headers(headers);
                     send_result(channel.clone(), callback, |cx| Ok(cx.undefined()));
                 }
+                RuntimeRequest::UpdateClientApiKey { client, key, callback } => {
+                    client.get_client().set_api_key(Some(key));
+                    send_result(channel.clone(), callback, |cx| Ok(cx.undefined()));
+                }
                 RuntimeRequest::PollLogs { callback } => {
                     let logs = core_runtime.telemetry().fetch_buffered_logs();
                     send_result(channel.clone(), callback, |cx| {
@@ -297,11 +300,15 @@ pub fn start_bridge_loop(
                     callback,
                 } => {
                     core_runtime.tokio_handle().spawn(async move {
+                        let stdout = Stdio::from(std::io::stdout());
+                        let stderr = Stdio::from(std::io::stderr());
                         let result = match config {
                             EphemeralServerConfig::TestServer(config) => {
-                                config.start_server().await
+                                config.start_server_with_output(stdout, stderr).await
+                            }
+                            EphemeralServerConfig::DevServer(config) => {
+                                config.start_server_with_output(stdout, stderr).await
                             }
-                            EphemeralServerConfig::DevServer(config) => config.start_server().await,
                         };
                         match result {
                             Err(err) => {
@@ -337,8 +344,7 @@ pub fn start_bridge_loop(
                                     format!("Failed to start test server: {}", err),
                                 )
                             },
-                        )
-                        .await
+                        ).await
                     });
                 }
                 RuntimeRequest::PushReplayHistory {
@@ -350,8 +356,8 @@ pub fn start_bridge_loop(
                         let sendfut = async move {
                             tx.send(pushme).await.map_err(|e| {
                                 format!(
-                    "Receive side of history replay channel is gone. This is an sdk bug. {:?}",
-                    e
+                                    "Receive side of history replay channel is gone. This is an sdk bug. {:?}",
+                                    e
                                 )
                             })
                         };
@@ -361,8 +367,7 @@ pub fn start_bridge_loop(
                                 UNEXPECTED_ERROR,
                                 format!("Error pushing replay history {}", err),
                             )
-                        })
-                        .await
+                        }).await
                     });
                 }
             }
@@ -453,24 +458,10 @@ pub fn client_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let callback = cx.argument::<JsFunction>(2)?;
 
     let client_options = opts.as_client_options(&mut cx)?;
-    let headers = match js_optional_getter!(&mut cx, &opts, "metadata", JsObject) {
-        None => None,
-        Some(h) => Some(
-            h.as_hash_map_of_string_to_string(&mut cx)
-                .map_err(|reason| {
-                    cx.throw_type_error::<_, HashMap<String, String>>(format!(
-                        "Invalid metadata: {}",
-                        reason
-                    ))
-                    .unwrap_err()
-                })?,
-        ),
-    };
 
     let request = RuntimeRequest::CreateClient {
         runtime: (**runtime).clone(),
         options: client_options,
-        headers,
         callback: callback.root(&mut cx),
     };
     if let Err(err) = runtime.sender.send(request) {
@@ -517,6 +508,31 @@ pub fn client_update_headers(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     Ok(cx.undefined())
 }
 
+/// Update a Client's API key
+pub fn client_update_api_key(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let client = cx.argument::<BoxedClient>(0)?;
+    let key = cx.argument::<JsString>(1)?.value(&mut cx);
+    let callback = cx.argument::<JsFunction>(2)?;
+
+    match client.borrow().as_ref() {
+        None => {
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Client")?;
+        }
+        Some(client) => {
+            let request = RuntimeRequest::UpdateClientApiKey {
+                client: client.core_client.clone(),
+                key,
+                callback: callback.root(&mut cx),
+            };
+            if let Err(err) = client.runtime.sender.send(request) {
+                callback_with_unexpected_error(&mut cx, callback, err)?;
+            };
+        }
+    }
+
+    Ok(cx.undefined())
+}
+
 pub(crate) struct HistoryForReplayTunnel {
     pub(crate) runtime: Arc<RuntimeHandle>,
     sender: Cell<Option<Sender<HistoryForReplay>>>,

package/ts/index.ts

@@ -1,7 +1,7 @@
 import { LogLevel, Duration } from '@temporalio/common';
-import type { TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
+import type { TLSConfig, ProxyConfig, HttpConnectProxyConfig } from '@temporalio/common/lib/internal-non-workflow';
 
-export { TLSConfig };
+export type { TLSConfig, ProxyConfig, HttpConnectProxyConfig };
 
 /** @deprecated Import from @temporalio/common instead */
 export { LogLevel };
@@ -55,6 +55,13 @@ export interface ClientOptions {
    */
   tls?: TLSConfig;
 
+  /**
+   * Proxying configuration.
+   *
+   * @experimental
+   */
+  proxy?: ProxyConfig;
+
   /**
    * Optional retry options for server requests.
    */
@@ -66,6 +73,14 @@ export interface ClientOptions {
    * Set statically at connection time, can be replaced later using {@link clientUpdateHeaders}.
    */
   metadata?: Record<string, string>;
+
+  /**
+   * API key for Temporal. This becomes the "Authorization" HTTP header with "Bearer " prepended.
+   * This is only set if RPC metadata doesn't already have an "authorization" key.
+   *
+   * Set statically at connection time, can be replaced later using {@link clientUpdateApiKey}.
+   */
+  apiKey?: string;
 }
 
 /**
@@ -122,11 +137,20 @@ export interface OtelCollectorExporter {
      * @defaults 1 second
      */
     metricsExportInterval?: Duration;
+    /**
+     * If set to true, the exporter will use seconds for durations instead of milliseconds.
+     */
+    useSecondsForDurations?: boolean;
   };
 }
 
 /** @experimental */
-export type CompiledOtelMetricsExporter = Shadow<OtelCollectorExporter, { otel: { metricsExportInterval: number } }>;
+export type CompiledOtelMetricsExporter = Shadow<
+  OtelCollectorExporter,
+  {
+    otel: { metricsExportInterval: number };
+  }
+>;
 
 /**
  * Prometheus metrics exporter options
@@ -142,6 +166,19 @@ export interface PrometheusMetricsExporter {
      * Metrics will be available for scraping under the standard `/metrics` route.
      */
     bindAddress: string;
+    /**
+     * If set to true, all counter names will include a "_total" suffix.
+     */
+    countersTotalSuffix?: boolean;
+    /**
+     * If set to true, all histograms will include the unit in their name as a suffix.
+     * EX: "_milliseconds"
+     */
+    unitSuffix?: boolean;
+    /**
+     * If set to true, the exporter will use seconds for durations instead of milliseconds.
+     */
+    useSecondsForDurations?: boolean;
   };
 }
 
@@ -430,18 +467,23 @@ export type EphemeralServerConfig = TimeSkippingServerConfig | DevServerConfig;
 export interface Worker {
   type: 'Worker';
 }
+
 export interface Runtime {
   type: 'Runtime';
 }
+
 export interface Client {
   type: 'Client';
 }
+
 export interface EphemeralServer {
   type: 'EphemeralServer';
 }
+
 export interface HistoryPusher {
   type: 'HistoryPusher';
 }
+
 export interface ReplayWorker {
   type: 'ReplayWorker';
   worker: Worker;
@@ -457,47 +499,69 @@ export declare type VoidCallback = (err: Error, result: void) => void;
 export declare type LogsCallback = (err: Error, result: LogEntry[]) => void;
 
 export declare function newRuntime(telemOptions: CompiledTelemetryOptions): Runtime;
+
 export declare function newClient(runtime: Runtime, clientOptions: ClientOptions, callback: ClientCallback): void;
+
 export declare function newWorker(client: Client, workerOptions: WorkerOptions, callback: WorkerCallback): void;
+
 export declare function newReplayWorker(
   runtime: Runtime,
   workerOptions: WorkerOptions,
   callback: ReplayWorkerCallback
 ): void;
+
 export declare function pushHistory(
   pusher: HistoryPusher,
   workflowId: string,
   history: ArrayBuffer,
   callback: VoidCallback
 ): void;
+
 export declare function closeHistoryStream(pusher: HistoryPusher): void;
+
 export declare function workerInitiateShutdown(worker: Worker, callback: VoidCallback): void;
+
 export declare function workerFinalizeShutdown(worker: Worker): void;
+
 export declare function clientUpdateHeaders(
   client: Client,
   headers: Record<string, string>,
   callback: VoidCallback
 ): void;
+
+export declare function clientUpdateApiKey(client: Client, apiKey: string, callback: VoidCallback): void;
+
 export declare function clientClose(client: Client): void;
+
 export declare function runtimeShutdown(runtime: Runtime, callback: VoidCallback): void;
+
 export declare function pollLogs(runtime: Runtime, callback: LogsCallback): void;
+
 export declare function workerPollWorkflowActivation(worker: Worker, callback: PollCallback): void;
+
 export declare function workerCompleteWorkflowActivation(
   worker: Worker,
   result: ArrayBuffer,
   callback: VoidCallback
 ): void;
+
 export declare function workerPollActivityTask(worker: Worker, callback: PollCallback): void;
+
 export declare function workerCompleteActivityTask(worker: Worker, result: ArrayBuffer, callback: VoidCallback): void;
+
 export declare function workerRecordActivityHeartbeat(worker: Worker, heartbeat: ArrayBuffer): void;
+
 export declare function getTimeOfDay(): [number, number];
+
 export declare function startEphemeralServer(
   runtime: Runtime,
   config: EphemeralServerConfig,
   sdkVersion: string,
   callback: Callback<EphemeralServer>
 ): void;
+
 export declare function shutdownEphemeralServer(server: EphemeralServer, callback: Callback<EphemeralServer>): void;
+
 export declare function getEphemeralServerTarget(server: EphemeralServer): string;
 
 export { ShutdownError, TransportError, UnexpectedError } from './errors';