This seems to be getting somewhere

Author: slinkydeveloper

src/context/mod.rs

@@ -632,7 +632,7 @@ pub trait ContextAwakeables<'ctx>: private::SealedContext<'ctx> {
         &self,
     ) -> (
         String,
-        impl Future<Output = Result<T, TerminalError>> + Send + Sync + 'ctx,
+        impl Future<Output = Result<T, TerminalError>> + Send  + 'ctx,
     ) {
         self.inner_context().awakeable()
     }

src/context/request.rs

@@ -72,6 +72,7 @@ impl fmt::Display for RequestTarget {
 pub struct Request<'a, Req, Res = ()> {
     ctx: &'a ContextInternal,
     request_target: RequestTarget,
+    idempotency_key: Option<String>,
     req: Req,
     res: PhantomData<Res>,
 }
@@ -81,40 +82,54 @@ impl<'a, Req, Res> Request<'a, Req, Res> {
         Self {
             ctx,
             request_target,
+            idempotency_key: None,
             req,
             res: PhantomData,
         }
     }
 
+    /// Add idempotency key to the request
+    pub fn idempotency_key(mut self, idempotency_key: impl Into<String>) -> Self {
+        self.idempotency_key = Some(idempotency_key.into());
+        self
+    }
+
     /// Call a service. This returns a future encapsulating the response.
     pub fn call(self) -> impl CallFuture<Result<Res, TerminalError>> + Send
     where
         Req: Serialize + 'static,
         Res: Deserialize + 'static,
     {
-        self.ctx.call(self.request_target, self.req)
+        self.ctx
+            .call(self.request_target, self.idempotency_key, self.req)
     }
 
     /// Send the request to the service, without waiting for the response.
     pub fn send(self) -> impl InvocationHandle
     where
         Req: Serialize + 'static,
     {
-        self.ctx.send(self.request_target, self.req, None)
+        self.ctx
+            .send(self.request_target, self.idempotency_key, self.req, None)
     }
 
     /// Schedule the request to the service, without waiting for the response.
     pub fn send_after(self, delay: Duration) -> impl InvocationHandle
     where
         Req: Serialize + 'static,
     {
-        self.ctx.send(self.request_target, self.req, Some(delay))
+        self.ctx.send(
+            self.request_target,
+            self.idempotency_key,
+            self.req,
+            Some(delay),
+        )
     }
 }
 
 pub trait InvocationHandle {
     fn invocation_id(&self) -> impl Future<Output = Result<String, TerminalError>> + Send;
-    fn cancel(&self);
+    fn cancel(&self) -> impl Future<Output = Result<(), TerminalError>> + Send;
 }
 
 pub trait CallFuture<O>: Future<Output = O> + InvocationHandle {}