@temporalio/core-bridge 1.6.0 → 1.7.1

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

@@ -34,6 +34,7 @@ async fn signal_sender(ctx: WfContext) -> WorkflowResult<()> {
 async fn sends_signal_to_missing_wf() {
     let wf_name = "sends_signal_to_missing_wf";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), signal_sender);
 
@@ -72,6 +73,7 @@ async fn signal_with_create_wf_receiver(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_other_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_to_other_wf");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf("sender", signal_sender);
     worker.register_wf("receiver", signal_receiver);
@@ -100,6 +102,7 @@ async fn sends_signal_to_other_wf() {
 #[tokio::test]
 async fn sends_signal_with_create_wf() {
     let mut starter = CoreWfStarter::new("sends_signal_with_create_wf");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf("receiver_signal", signal_with_create_wf_receiver);
 
@@ -150,6 +153,7 @@ async fn signals_child(ctx: WfContext) -> WorkflowResult<()> {
 #[tokio::test]
 async fn sends_signal_to_child() {
     let mut starter = CoreWfStarter::new("sends_signal_to_child");
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf("child_signaler", signals_child);
     worker.register_wf("child_receiver", signal_receiver);

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

@@ -12,6 +12,7 @@ use tokio::sync::Barrier;
 async fn timer_workflow_not_sticky() {
     let wf_name = "timer_wf_not_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     starter.max_cached_workflows(0);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
@@ -39,6 +40,7 @@ async fn timer_workflow_timeout_on_sticky() {
     // on a not-sticky queue
     let wf_name = "timer_workflow_timeout_on_sticky";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     starter.workflow_options.task_timeout = Some(Duration::from_secs(2));
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_timeout_wf);
@@ -53,7 +55,7 @@ async fn timer_workflow_timeout_on_sticky() {
 async fn cache_miss_ok() {
     let wf_name = "cache_miss_ok";
     let mut starter = CoreWfStarter::new(wf_name);
-    starter.max_wft(1);
+    starter.no_remote_activities().max_wft(1);
     let mut worker = starter.worker().await;
 
     let barr: &'static Barrier = Box::leak(Box::new(Barrier::new(2)));

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

@@ -6,7 +6,8 @@ use temporal_sdk_core_protos::coresdk::{
     workflow_completion::WorkflowActivationCompletion,
 };
 use temporal_sdk_core_test_utils::{
-    init_core_and_create_wf, start_timer_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, init_core_and_create_wf, start_timer_cmd, CoreWfStarter,
+    WorkerTestHelpers,
 };
 
 pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
@@ -18,6 +19,7 @@ pub async fn timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn timer_workflow_workflow_driver() {
     let wf_name = "timer_wf_new";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), timer_wf);
 
@@ -29,6 +31,7 @@ async fn timer_workflow_workflow_driver() {
 async fn timer_workflow_manual() {
     let mut starter = init_core_and_create_wf("timer_workflow").await;
     let core = starter.get_worker().await;
+    starter.no_remote_activities();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -42,13 +45,14 @@ async fn timer_workflow_manual() {
     .unwrap();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_execution(&task.run_id).await;
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
 }
 
 #[tokio::test]
 async fn timer_cancel_workflow() {
     let mut starter = init_core_and_create_wf("timer_cancel_workflow").await;
     let core = starter.get_worker().await;
+    starter.no_remote_activities();
     let task = core.poll_workflow_activation().await.unwrap();
     core.complete_workflow_activation(WorkflowActivationCompletion::from_cmds(
         task.run_id,
@@ -107,6 +111,7 @@ async fn parallel_timer_wf(command_sink: WfContext) -> WorkflowResult<()> {
 async fn parallel_timers() {
     let wf_name = "parallel_timers";
     let mut starter = CoreWfStarter::new(wf_name);
+    starter.no_remote_activities();
     let mut worker = starter.worker().await;
     worker.register_wf(wf_name.to_owned(), parallel_timer_wf);
 

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

@@ -2,7 +2,7 @@ use std::{collections::HashMap, env};
 use temporal_client::{WorkflowClientTrait, WorkflowOptions};
 use temporal_sdk::{WfContext, WorkflowResult};
 use temporal_sdk_core_protos::coresdk::{AsJsonPayloadExt, FromJsonPayloadExt};
-use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORALITE_USED_ENV_VAR};
+use temporal_sdk_core_test_utils::{CoreWfStarter, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR};
 use tracing::warn;
 use uuid::Uuid;
 
@@ -24,9 +24,11 @@ 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();
     let mut worker = starter.worker().await;
-    if env::var(INTEG_TEMPORALITE_USED_ENV_VAR).is_ok() {
-        warn!("skipping sends_upsert -- does not work on temporalite");
+    // 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() {
+        warn!("skipping sends_upsert -- does not work on temporal dev server");
         return;
     }
 
@@ -62,10 +64,7 @@ async fn sends_upsert() {
     let txt_attr_payload = search_attrs.get(TXT_ATTR).unwrap();
     let int_attr_payload = search_attrs.get(INT_ATTR).unwrap();
     for payload in [txt_attr_payload, int_attr_payload] {
-        assert_eq!(
-            &b"json/plain".to_vec(),
-            payload.metadata.get("encoding").unwrap()
-        );
+        assert!(payload.is_json_payload());
     }
     assert_eq!(
         "goodbye",

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

@@ -42,8 +42,8 @@ use temporal_sdk_core_protos::{
     temporal::api::{failure::v1::Failure, history::v1::history_event},
 };
 use temporal_sdk_core_test_utils::{
-    history_from_proto_binary, init_core_and_create_wf, init_core_replay_preloaded,
-    schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
+    drain_pollers_and_shutdown, history_from_proto_binary, init_core_and_create_wf,
+    init_core_replay_preloaded, schedule_activity_cmd, CoreWfStarter, WorkerTestHelpers,
 };
 use tokio::time::sleep;
 use uuid::Uuid;
@@ -103,7 +103,7 @@ async fn parallel_workflows_same_queue() {
     for handle in handles {
         handle.await.unwrap()
     }
-    core.shutdown().await;
+    drain_pollers_and_shutdown(&core).await;
 }
 
 static RUN_CT: AtomicUsize = AtomicUsize::new(0);
@@ -117,7 +117,7 @@ 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.max_cached_workflows(1);
+    starter.no_remote_activities().max_cached_workflows(1);
     let mut worker = starter.worker().await;
     worker.register_wf(wf_type.to_string(), cache_evictions_wf);
 
@@ -162,7 +162,7 @@ async fn shutdown_aborts_actively_blocked_poll() {
     let tcore = core.clone();
     let handle = tokio::spawn(async move {
         std::thread::sleep(Duration::from_millis(100));
-        tcore.shutdown().await;
+        drain_pollers_and_shutdown(&tcore).await;
     });
     assert_matches!(
         core.poll_workflow_activation().await.unwrap_err(),
@@ -414,11 +414,11 @@ async fn signal_workflow_signal_not_handled_on_workflow_completion() {
             res.jobs.as_slice(),
             [
                 WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
+                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
                 },
                 WorkflowActivationJob {
-                    variant: Some(workflow_activation_job::Variant::SignalWorkflow(_)),
-                }
+                    variant: Some(workflow_activation_job::Variant::FireTimer(_)),
+                },
             ]
         );
         core.complete_execution(&res.run_id).await;

package/sdk-core/tests/main.rs

@@ -25,7 +25,7 @@ mod integ_tests {
     use temporal_sdk_core_api::worker::WorkerConfigBuilder;
     use temporal_sdk_core_protos::temporal::api::workflowservice::v1::ListNamespacesRequest;
     use temporal_sdk_core_test_utils::{
-        get_integ_server_options, get_integ_telem_options, NAMESPACE,
+        get_integ_server_options, get_integ_telem_options, init_integ_telem,
     };
     use url::Url;
 
@@ -36,7 +36,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.metric_meter(), None)
+            .connect_no_namespace(runtime.metric_meter().as_deref(), None)
             .await
             .unwrap();
 
@@ -58,35 +58,23 @@ mod integ_tests {
             .await;
     }
 
-    // TODO: Currently ignored because starting up the docker image with TLS requires some hoop
-    //  jumping. We should upgrade CI to be able to do that but this was manually run against
-    //  https://github.com/temporalio/customization-samples/tree/master/tls/tls-simple
+    // Manually run to verify tls works against cloud. You will need certs in place in the
+    // indicated directory.
     #[tokio::test]
     #[ignore]
     async fn tls_test() {
-        // Load certs/keys
-        let root = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/ca.cert",
-        )
-        .await
-        .unwrap();
-        let client_cert = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/client.pem",
-        )
-        .await
-        .unwrap();
-        let client_private_key = tokio::fs::read(
-            "/home/sushi/dev/temporal/customization-samples/tls/tls-simple/certs/client.key",
-        )
-        .await
-        .unwrap();
+        init_integ_telem();
+        let root = tokio::fs::read("../.cloud_certs/ca.pem").await.unwrap();
+        let client_cert = tokio::fs::read("../.cloud_certs/client.pem").await.unwrap();
+        let client_private_key = tokio::fs::read("../.cloud_certs/client.key").await.unwrap();
         let sgo = ClientOptionsBuilder::default()
-            .target_url(Url::from_str("https://localhost:7233").unwrap())
+            .target_url(Url::from_str("https://spencer.temporal-dev.tmprl.cloud:7233").unwrap())
             .client_name("tls_tester")
             .client_version("clientver")
             .tls_cfg(TlsConfig {
                 server_root_ca_cert: Some(root),
-                domain: Some("tls-sample".to_string()),
+                // Not necessary, but illustrates functionality for people using proxies, etc.
+                domain: Some("spencer.temporal-dev.tmprl.cloud".to_string()),
                 client_tls_config: Some(ClientTlsConfig {
                     client_cert,
                     client_private_key,
@@ -95,9 +83,12 @@ mod integ_tests {
             .build()
             .unwrap();
         let con = sgo
-            .connect(NAMESPACE.to_string(), None, None)
+            .connect("spencer.temporal-dev".to_string(), None, None)
             .await
             .unwrap();
-        con.list_namespaces().await.unwrap();
+        dbg!(con
+            .list_workflow_executions(100, vec![], "".to_string())
+            .await
+            .unwrap());
     }
 }

package/sdk-core/tests/runner.rs

@@ -5,9 +5,11 @@ use std::{
     path::{Path, PathBuf},
     process::Stdio,
 };
-use temporal_sdk_core::ephemeral_server::{TemporaliteConfigBuilder, TestServerConfigBuilder};
+use temporal_sdk_core::ephemeral_server::{
+    TemporalDevServerConfigBuilder, TestServerConfigBuilder,
+};
 use temporal_sdk_core_test_utils::{
-    default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORALITE_USED_ENV_VAR,
+    default_cached_download, INTEG_SERVER_TARGET_ENV_VAR, INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR,
     INTEG_TEST_SERVER_USED_ENV_VAR,
 };
 use tokio::{self, process::Command};
@@ -20,7 +22,7 @@ struct Cli {
     test_name: String,
 
     /// What kind of server to auto-launch, if any
-    #[arg(short, long, value_enum, default_value = "temporalite")]
+    #[arg(short, long, value_enum, default_value = "temporal-cli")]
     server_kind: ServerKind,
 
     /// Arguments to pass through to the `cargo test` command. Ex: `--release`
@@ -33,8 +35,8 @@ struct Cli {
 
 #[derive(Copy, Clone, PartialEq, Eq, clap::ValueEnum)]
 enum ServerKind {
-    /// Use Temporalite
-    Temporalite,
+    /// Use Temporal-cli
+    TemporalCLI,
     /// Use the Java test server
     TestServer,
     /// Do not automatically start any server
@@ -65,14 +67,14 @@ async fn main() -> Result<(), anyhow::Error> {
     }
 
     let (server, envs) = match server_kind {
-        ServerKind::Temporalite => {
-            let config = TemporaliteConfigBuilder::default()
+        ServerKind::TemporalCLI => {
+            let config = TemporalDevServerConfigBuilder::default()
                 .exe(default_cached_download())
                 .build()?;
-            println!("Using temporalite");
+            println!("Using temporal CLI");
             (
                 Some(config.start_server_with_output(Stdio::null()).await?),
-                vec![(INTEG_TEMPORALITE_USED_ENV_VAR, "true")],
+                vec![(INTEG_TEMPORAL_DEV_SERVER_USED_ENV_VAR, "true")],
             )
         }
         ServerKind::TestServer => {

package/src/conversions.rs

@@ -14,14 +14,15 @@ use temporal_sdk_core::{
     },
     api::worker::{WorkerConfig, WorkerConfigBuilder},
     ephemeral_server::{
-        TemporaliteConfig, TemporaliteConfigBuilder, TestServerConfig, TestServerConfigBuilder,
+        TemporalDevServerConfig, TemporalDevServerConfigBuilder, TestServerConfig,
+        TestServerConfigBuilder,
     },
     ClientOptions, ClientOptionsBuilder, ClientTlsConfig, RetryConfig, TlsConfig, Url,
 };
 
 pub enum EphemeralServerConfig {
     TestServer(TestServerConfig),
-    Temporalite(TemporaliteConfig),
+    DevServer(TemporalDevServerConfig),
 }
 
 pub trait ArrayHandleConversionsExt {
@@ -323,6 +324,10 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             js_optional_getter!(cx, self, "maxTaskQueueActivitiesPerSecond", JsNumber)
                 .map(|num| num.value(cx) as f64);
 
+        let graceful_shutdown_period =
+            js_optional_getter!(cx, self, "shutdownGraceTimeMs", JsNumber)
+                .map(|num| Duration::from_millis(num.value(cx) as u64));
+
         match WorkerConfigBuilder::default()
             .worker_build_id(js_value_getter!(cx, self, "buildId", JsString))
             .client_identity_override(Some(js_value_getter!(cx, self, "identity", JsString)))
@@ -332,6 +337,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
             .max_outstanding_local_activities(max_outstanding_local_activities)
             .max_cached_workflows(max_cached_workflows)
             .sticky_queue_schedule_to_start_timeout(sticky_queue_schedule_to_start_timeout)
+            .graceful_shutdown_period(graceful_shutdown_period)
             .namespace(namespace)
             .task_queue(task_queue)
             .max_heartbeat_throttle_interval(max_heartbeat_throttle_interval)
@@ -374,7 +380,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
 
                 let exec_version = match version.as_str() {
                     "default" => {
-                        temporal_sdk_core::ephemeral_server::EphemeralExeVersion::Default {
+                        temporal_sdk_core::ephemeral_server::EphemeralExeVersion::SDKDefault {
                             sdk_name: "sdk-typescript".to_owned(),
                             sdk_version,
                         }
@@ -398,8 +404,8 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
 
         let server_type = js_value_getter!(cx, self, "type", JsString);
         match server_type.as_str() {
-            "temporalite" => {
-                let mut config = TemporaliteConfigBuilder::default();
+            "dev-server" => {
+                let mut config = TemporalDevServerConfigBuilder::default();
                 config.exe(executable).port(port);
 
                 if let Some(extra_args) = js_optional_getter!(cx, self, "extraArgs", JsArray) {
@@ -422,9 +428,9 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                 }
 
                 match config.build() {
-                    Ok(config) => Ok(EphemeralServerConfig::Temporalite(config)),
+                    Ok(config) => Ok(EphemeralServerConfig::DevServer(config)),
                     Err(err) => {
-                        cx.throw_type_error(format!("Invalid temporalite config: {:?}", err))
+                        cx.throw_type_error(format!("Invalid dev server config: {:?}", err))
                     }
                 }
             }
@@ -445,7 +451,7 @@ impl ObjectHandleConversionsExt for Handle<'_, JsObject> {
                 }
             }
             s => cx.throw_type_error(format!(
-                "Invalid ephemeral server type: {}, expected 'temporalite' or 'time-skipping'",
+                "Invalid ephemeral server type: {}, expected 'dev-server' or 'time-skipping'",
                 s
             )),
         }

package/src/runtime.rs

@@ -144,13 +144,16 @@ pub fn start_bridge_loop(
                     headers,
                     callback,
                 } => {
-                    // `metrics_meter` (second arg) can be None here since we don't use the
-                    // returned client directly at the moment, when we repurpose the client to be
-                    // used by a Worker, `init_worker` will attach the correct metrics meter for
-                    // us.
+                    // `metrics_meter` can be None here since we don't use the returned client
+                    // directly at the moment, when we repurpose the client to be used by a Worker,
+                    // `init_worker` will attach the correct metrics meter for us.
                     core_runtime.tokio_handle().spawn(async move {
+                        let metrics_meter = None;
                         match options
-                            .connect_no_namespace(None, headers.map(|h| Arc::new(RwLock::new(h))))
+                            .connect_no_namespace(
+                                metrics_meter,
+                                headers.map(|h| Arc::new(RwLock::new(h))),
+                            )
                             .await
                         {
                             Err(err) => {
@@ -270,9 +273,7 @@ pub fn start_bridge_loop(
                             EphemeralServerConfig::TestServer(config) => {
                                 config.start_server().await
                             }
-                            EphemeralServerConfig::Temporalite(config) => {
-                                config.start_server().await
-                            }
+                            EphemeralServerConfig::DevServer(config) => config.start_server().await,
                         };
                         match result {
                             Err(err) => {

package/ts/index.ts

@@ -381,10 +381,10 @@ export interface TimeSkippingServerConfig {
 }
 
 /**
- * Configuration for temporalite.
+ * Configuration for the Temporal CLI dev server.
  */
-export interface TemporaliteConfig {
-  type: 'temporalite';
+export interface DevServerConfig {
+  type: 'dev-server';
   executable?: EphemeralServerExecutable;
   /**
    * Namespace to use - created at startup.
@@ -399,11 +399,13 @@ export interface TemporaliteConfig {
    */
   ip?: string;
   /**
-   * Sqlite DB filename if persisting or non-persistent if none.
+   * Sqlite DB filename if persisting or non-persistent if none (default).
    */
   db_filename?: string;
   /**
    * Whether to enable the UI.
+   *
+   * @default false
    */
   ui?: boolean;
   /**
@@ -424,9 +426,9 @@ export interface TemporaliteConfig {
 /**
  * Configuration for spawning an ephemeral Temporal server.
  *
- * Both the time-skipping test server and temporalite are supported.
+ * Both the time-skipping test server and Temporal CLI dev server are supported.
  */
-export type EphemeralServerConfig = TimeSkippingServerConfig | TemporaliteConfig;
+export type EphemeralServerConfig = TimeSkippingServerConfig | DevServerConfig;
 
 export interface Worker {
   type: 'Worker';

package/sdk-core/protos/api_upstream/temporal/api/interaction/v1/message.proto

@@ -1,87 +0,0 @@
-// The MIT License
-//
-// Copyright (c) 2020 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.
-
-syntax = "proto3";
-
-package temporal.api.interaction.v1;
-
-option go_package = "go.temporal.io/api/interaction/v1;interaction";
-option java_package = "io.temporal.api.interaction.v1";
-option java_multiple_files = true;
-option java_outer_classname = "MessageProto";
-option ruby_package = "Temporalio::Api::Interaction::V1";
-option csharp_namespace = "Temporalio.Api.Interaction.V1";
-
-import "temporal/api/common/v1/message.proto";
-import "temporal/api/failure/v1/message.proto";
-import "temporal/api/enums/v1/interaction_type.proto";
-
-// Meta carries metadata about an interaction for use by the system (i.e. not
-// generall user-visible)
-message Meta {
-    // An ID with workflow-scoped uniqueness for this interaction
-    string id = 1;
-
-    // The event ID after which this interaction can execute. The effects of
-    // history up to and including this event ID should be visible to the
-    // interaction when it executes.
-    int64 event_id = 2;
-
-    // The type of this interaction.
-    temporal.api.enums.v1.InteractionType interaction_type = 3;
-
-    // A string identifying the agent that requested this interaction.
-    string identity = 4;
-
-    string request_id = 5;
-}
-
-// Input carries interaction input that comes from the caller.
-message Input {
-    // Headers that are passed with the interaction to and from the processing workflow.
-    // These can include things like auth or tracing tokens.
-    temporal.api.common.v1.Header header = 1;
-
-    // The name of the input handler to invoke on the target workflow
-    string name = 2;
-
-    // The arguments to pass to the named handler.
-    temporal.api.common.v1.Payloads args = 3;
-}
-
-
-// Output carries the output data from an interaction.
-message Output {
-    // Headers that are passed with the interaction to and from the processing workflow.
-    // These can include things like auth or tracing tokens.
-    temporal.api.common.v1.Header header = 1;
-
-    oneof result {
-        temporal.api.common.v1.Payloads success = 2;
-        temporal.api.failure.v1.Failure failure = 3;
-    }
-}
-
-message Invocation {
-    Meta meta = 1;
-    Input input = 2;
-}