Bump restate-sdk-shared-core to 0.7.1 and update outdated dependencies

Bump restate-sdk-shared-core from 0.6.0 to 0.7.1 and update other
outdated dependencies to their latest versions (aws_lambda_events 1.0,
lambda_runtime 1.0, typify 0.6, jsonptr 0.7, regress 0.10).

Adapt to breaking changes:
- TerminalFailure now has a metadata field
- PayloadOptions parameter added to multiple VM syscalls
- TypeSpace::new() now takes a reference to settings
- typify generates NonZero<u64> for protocol version fields
- Base64Data is now #[non_exhaustive]
- notify_error signature changed

Closes #92

Author: tillrohrmann

Cargo.toml

@@ -25,44 +25,44 @@ tracing-span-filter = ["dep:tracing-subscriber"]
 lambda = [ "dep:http-serde", "dep:lambda_runtime", "dep:aws_lambda_events"]
 
 [dependencies]
-bytes = "1.10"
+bytes = "1.11"
 futures = "0.3"
-http = "1.3"
+http = "1.4"
 http-body = "1.0.1"
 http-body-util = { version = "0.1", optional = true }
-hyper = { version = "1.6", optional = true}
+hyper = { version = "1.8", optional = true}
 hyper-util = { version = "0.1", features = ["tokio", "server", "server-graceful", "http2"], optional = true }
 pin-project-lite = "0.2"
-rand = { version = "0.9", optional = true }
-regress = "=0.10.3"
+rand = { version = "0.10", optional = true }
+regress = "0.10"
 restate-sdk-macros = { version = "0.8", path = "macros" }
-restate-sdk-shared-core = { version = "=0.6.0", features = ["request_identity", "sha2_random_seed", "http"] }
-schemars = { version = "1.0.0", optional = true }
+restate-sdk-shared-core = { version = "=0.7.1", features = ["request_identity", "sha2_random_seed", "http"] }
+schemars = { version = "1.2", optional = true }
 serde = "1.0"
 serde_json = "1.0"
 thiserror = "2.0"
-tokio = { version = "1.44", default-features = false, features = ["sync"] }
+tokio = { version = "1.49", default-features = false, features = ["sync"] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["registry"], optional = true }
-uuid = { version = "1.16.0", optional = true }
+uuid = { version = "1.20", optional = true }
 http-serde = { version = "2.1.1", optional = true }
-aws_lambda_events = { version = "0.16.1", optional = true }
-lambda_runtime = { version = "0.14.2", optional = true }
+aws_lambda_events = { version = "1.0", optional = true }
+lambda_runtime = { version = "1.0", optional = true }
 
 [dev-dependencies]
 tokio = { version = "1", features = ["full"] }
 tracing-subscriber = { version = "0.3", features = ["env-filter", "registry"] }
 trybuild = "1.0"
-reqwest = { version = "0.12", features = ["json"] }
-rand = "0.9"
-schemars = "1.0.0-alpha.17"
+reqwest = { version = "0.13", features = ["json"] }
+rand = "0.10"
+schemars = "1.2"
 
 [build-dependencies]
-jsonptr = "0.5.1"
+jsonptr = "0.7"
 prettyplease = "0.2"
 serde_json = { version = "1.0" }
 syn = "2.0"
-typify = { version = "0.1.0" }
+typify = { version = "0.6" }
 
 [workspace]
 members = ["macros", "test-services", "testcontainers"]

build.rs

@@ -46,11 +46,8 @@ fn main() -> std::io::Result<()> {
         .add_root_schema(serde_json::from_value(parsed_content).unwrap())
         .unwrap();
 
-    let contents = format!(
-        "{}\n{}",
-        "use serde::{Deserialize, Serialize};",
-        prettyplease::unparse(&syn::parse2::<syn::File>(type_space.to_stream()).unwrap())
-    );
-
-    std::fs::write(out_dir.join("endpoint_manifest.rs"), contents)
+    std::fs::write(
+        out_dir.join("endpoint_manifest.rs"),
+        prettyplease::unparse(&syn::parse2::<syn::File>(type_space.to_stream()).unwrap()),
+    )
 }

examples/failures.rs

@@ -1,4 +1,4 @@
-use rand::RngCore;
+use rand::Rng;
 use restate_sdk::prelude::*;
 
 #[restate_sdk::service]

src/context/mod.rs

@@ -779,13 +779,13 @@ pub trait ContextSideEffects<'ctx>: private::SealedContext<'ctx> {
 
     /// ### Generating random numbers
     ///
-    /// Return a [`rand::Rng`] instance inherently predictable, seeded with [`ContextSideEffects::random_seed`].
+    /// Return a [`rand::RngExt`] instance inherently predictable, seeded with [`ContextSideEffects::random_seed`].
     ///
     /// For example, you can use this to generate a random number:
     ///
     /// ```rust,no_run
     /// # use restate_sdk::prelude::*;
-    /// # use rand::Rng;
+    /// # use rand::RngExt;
     /// async fn rand_generate(mut ctx: Context<'_>) {
     /// let x: u32 = ctx.rand().random();
     /// # }
@@ -815,7 +815,7 @@ pub trait ContextSideEffects<'ctx>: private::SealedContext<'ctx> {
     #[cfg(all(feature = "rand", feature = "uuid"))]
     fn rand_uuid(&mut self) -> uuid::Uuid {
         let rand = private::SealedContext::rand(self);
-        uuid::Uuid::from_u64_pair(rand::RngCore::next_u64(rand), rand::RngCore::next_u64(rand))
+        uuid::Uuid::from_u64_pair(rand::Rng::next_u64(rand), rand::Rng::next_u64(rand))
     }
 }
 

src/discovery.rs

@@ -3,6 +3,7 @@
 mod generated {
     #![allow(clippy::clone_on_copy)]
     #![allow(clippy::to_string_trait_impl)]
+    #![allow(clippy::derivable_impls)]
 
     include!(concat!(env!("OUT_DIR"), "/endpoint_manifest.rs"));
 }

src/endpoint/context.rs

@@ -16,7 +16,8 @@ use futures::{FutureExt, TryFutureExt};
 use pin_project_lite::pin_project;
 use restate_sdk_shared_core::{
     CoreVM, DoProgressResponse, Error as CoreError, Header, NonEmptyValue, NotificationHandle,
-    RetryPolicy, RunExitResult, TakeOutputResult, Target, TerminalFailure, VM, Value,
+    PayloadOptions, RetryPolicy, RunExitResult, TakeOutputResult, Target, TerminalFailure, VM,
+    Value,
 };
 use std::borrow::Cow;
 use std::collections::HashMap;
@@ -59,7 +60,7 @@ impl ContextInternalInner {
         self.maybe_flip_span_replaying_field();
         self.vm.notify_error(
             CoreError::new(500u16, e.0.to_string())
-                .with_stacktrace(Cow::Owned(format!("{:#}", e.0))),
+                .with_stacktrace(Cow::<str>::Owned(format!("{:#}", e.0))),
             None,
         );
         self.handler_state.mark_error(e);
@@ -237,7 +238,7 @@ impl ContextInternal {
                 };
                 let _ = inner_lock
                     .vm
-                    .sys_write_output(NonEmptyValue::Failure(err.into()));
+                    .sys_write_output(NonEmptyValue::Failure(err.into()), PayloadOptions::stable());
                 let _ = inner_lock.vm.sys_end();
                 // This causes the trap, plus logs the error
                 inner_lock.handler_state.mark_error(error_inner.into());
@@ -256,7 +257,12 @@ impl ContextInternal {
         key: &str,
     ) -> impl Future<Output = Result<Option<T>, TerminalError>> + Send {
         let mut inner_lock = must_lock!(self.inner);
-        let handle = unwrap_or_trap!(inner_lock, inner_lock.vm.sys_state_get(key.to_owned()));
+        let handle = unwrap_or_trap!(
+            inner_lock,
+            inner_lock
+                .vm
+                .sys_state_get(key.to_owned(), PayloadOptions::stable())
+        );
         inner_lock.maybe_flip_span_replaying_field();
 
         let poll_future = get_async_result(Arc::clone(&self.inner), handle).map(|res| match res {
@@ -301,7 +307,9 @@ impl ContextInternal {
         let mut inner_lock = must_lock!(self.inner);
         match t.serialize() {
             Ok(b) => {
-                let _ = inner_lock.vm.sys_state_set(key.to_owned(), b);
+                let _ = inner_lock
+                    .vm
+                    .sys_state_set(key.to_owned(), b, PayloadOptions::stable());
                 inner_lock.maybe_flip_span_replaying_field();
             }
             Err(e) => {
@@ -391,7 +399,12 @@ impl ContextInternal {
             .collect();
         let call_result = Req::serialize(&req)
             .map_err(|e| Error::serialization("call", e))
-            .and_then(|input| inner_lock.vm.sys_call(target, input).map_err(Into::into));
+            .and_then(|input| {
+                inner_lock
+                    .vm
+                    .sys_call(target, input, PayloadOptions::stable())
+                    .map_err(Into::into)
+            });
 
         let call_handle = match call_result {
             Ok(t) => t,
@@ -487,6 +500,7 @@ impl ContextInternal {
                     .expect("Duration since unix epoch cannot fail")
                     + delay
             }),
+            PayloadOptions::stable(),
         ) {
             Ok(h) => h,
             Err(e) => {
@@ -579,9 +593,11 @@ impl ContextInternal {
         let mut inner_lock = must_lock!(self.inner);
         match t.serialize() {
             Ok(b) => {
-                let _ = inner_lock
-                    .vm
-                    .sys_complete_awakeable(id.to_owned(), NonEmptyValue::Success(b));
+                let _ = inner_lock.vm.sys_complete_awakeable(
+                    id.to_owned(),
+                    NonEmptyValue::Success(b),
+                    PayloadOptions::stable(),
+                );
             }
             Err(e) => {
                 inner_lock.fail(Error::serialization("resolve_awakeable", e));
@@ -590,9 +606,11 @@ impl ContextInternal {
     }
 
     pub fn reject_awakeable(&self, id: &str, failure: TerminalError) {
-        let _ = must_lock!(self.inner)
-            .vm
-            .sys_complete_awakeable(id.to_owned(), NonEmptyValue::Failure(failure.into()));
+        let _ = must_lock!(self.inner).vm.sys_complete_awakeable(
+            id.to_owned(),
+            NonEmptyValue::Failure(failure.into()),
+            PayloadOptions::stable(),
+        );
     }
 
     pub fn promise<T: Deserialize>(
@@ -657,9 +675,11 @@ impl ContextInternal {
         let mut inner_lock = must_lock!(self.inner);
         match t.serialize() {
             Ok(b) => {
-                let _ = inner_lock
-                    .vm
-                    .sys_complete_promise(name.to_owned(), NonEmptyValue::Success(b));
+                let _ = inner_lock.vm.sys_complete_promise(
+                    name.to_owned(),
+                    NonEmptyValue::Success(b),
+                    PayloadOptions::stable(),
+                );
             }
             Err(e) => {
                 inner_lock.fail(
@@ -674,9 +694,11 @@ impl ContextInternal {
     }
 
     pub fn reject_promise(&self, id: &str, failure: TerminalError) {
-        let _ = must_lock!(self.inner)
-            .vm
-            .sys_complete_promise(id.to_owned(), NonEmptyValue::Failure(failure.into()));
+        let _ = must_lock!(self.inner).vm.sys_complete_promise(
+            id.to_owned(),
+            NonEmptyValue::Failure(failure.into()),
+            PayloadOptions::stable(),
+        );
     }
 
     pub fn run<'a, Run, Fut, Out>(
@@ -719,7 +741,9 @@ impl ContextInternal {
             },
         };
 
-        let _ = inner_lock.vm.sys_write_output(res_to_write);
+        let _ = inner_lock
+            .vm
+            .sys_write_output(res_to_write, PayloadOptions::stable());
         inner_lock.maybe_flip_span_replaying_field();
     }
 
@@ -886,6 +910,7 @@ where
                                     Ok(Err(TerminalError::from(TerminalFailure {
                                         code: 409,
                                         message: "cancelled".to_string(),
+                                        metadata: vec![],
                                     })))
                                 }
                                 .boxed(),

src/endpoint/futures/async_result_poll.rs

@@ -121,6 +121,7 @@ impl Future for VmAsyncResultPollFuture {
                             return Poll::Ready(Ok(Value::Failure(TerminalFailure {
                                 code: 409,
                                 message: "cancelled".to_string(),
+                                metadata: vec![],
                             })));
                         }
                         Err(e) => {

src/endpoint/futures/select_poll.rs

@@ -124,6 +124,7 @@ impl Future for VmSelectAsyncResultPollFuture {
                             return Poll::Ready(Ok(Err(TerminalFailure {
                                 code: 409,
                                 message: "cancelled".to_string(),
+                                metadata: vec![],
                             }
                             .into())));
                         }

src/endpoint/mod.rs

@@ -333,8 +333,8 @@ impl Endpoint {
             Bytes::from(
                 serde_json::to_string(&crate::discovery::Endpoint {
                     lambda_compression: None,
-                    max_protocol_version: 5,
-                    min_protocol_version: 5,
+                    max_protocol_version: std::num::NonZero::new(5).unwrap(),
+                    min_protocol_version: std::num::NonZero::new(5).unwrap(),
                     protocol_mode: Some(match protocol_mode {
                         ProtocolMode::RequestResponse => {
                             crate::discovery::ProtocolMode::RequestResponse

src/errors.rs

@@ -155,6 +155,7 @@ impl From<TerminalError> for TerminalFailure {
         Self {
             code: value.0.code,
             message: value.0.message,
+            metadata: vec![],
         }
     }
 }