diff --git a/lambda-http/src/lib.rs b/lambda-http/src/lib.rs
index ec80c30b..0421350e 100644
--- a/lambda-http/src/lib.rs
+++ b/lambda-http/src/lib.rs
@@ -63,7 +63,7 @@ extern crate maplit;
 
 pub use http::{self, Response};
 pub use lambda_runtime::{self, Context};
-use lambda_runtime::{Error, Handler as LambdaHandler};
+use lambda_runtime::{tower::Service, Error, LambdaRequest as RuntimeRequest};
 
 mod body;
 pub mod ext;
@@ -164,13 +164,18 @@ impl<'a, H: Handler<'a>> Handler<'a> for Adapter<'a, H> {
     }
 }
 
-impl<'a, 'b, H: Handler<'a>> LambdaHandler<LambdaRequest<'b>, LambdaResponse> for Adapter<'a, H> {
+impl<'a, 'b, H: Handler<'a>> Service<RuntimeRequest<LambdaRequest<'b>>> for Adapter<'a, H> {
     type Error = H::Error;
-    type Fut = TransformResponse<'a, H::Response, Self::Error>;
+    type Response = LambdaResponse;
+    type Future = TransformResponse<'a, H::Response, Self::Error>;
 
-    fn call(&mut self, event: LambdaRequest<'_>, context: Context) -> Self::Fut {
-        let request_origin = event.request_origin();
-        let fut = Box::pin(self.handler.call(event.into(), context));
+    fn poll_ready(&mut self, _cx: &mut core::task::Context<'_>) -> core::task::Poll<Result<(), Self::Error>> {
+        core::task::Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: RuntimeRequest<LambdaRequest<'_>>) -> Self::Future {
+        let request_origin = req.event.request_origin();
+        let fut = Box::pin(self.handler.call(req.event.into(), req.context));
         TransformResponse { request_origin, fut }
     }
 }
diff --git a/lambda-runtime/Cargo.toml b/lambda-runtime/Cargo.toml
index 4d0de675..c86278f3 100644
--- a/lambda-runtime/Cargo.toml
+++ b/lambda-runtime/Cargo.toml
@@ -25,7 +25,7 @@ async-stream = "0.3"
 futures = "0.3"
 tracing-error = "0.2"
 tracing = { version = "0.1", features = ["log"] }
-tower-service = "0.3"
+tower = { version = "0.4", features = ["util"] }
 tokio-stream = "0.1.2"
 
 [dev-dependencies]
diff --git a/lambda-runtime/src/lib.rs b/lambda-runtime/src/lib.rs
index 30220e45..bb5cc800 100644
--- a/lambda-runtime/src/lib.rs
+++ b/lambda-runtime/src/lib.rs
@@ -17,9 +17,11 @@ use std::{
 };
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_stream::{Stream, StreamExt};
-use tower_service::Service;
+pub use tower;
 use tracing::{error, trace};
 
+use tower::{service_fn, util::ServiceFn, Service};
+
 mod client;
 mod requests;
 #[cfg(test)]
@@ -30,6 +32,8 @@ mod types;
 use requests::{EventCompletionRequest, EventErrorRequest, IntoRequest, NextEventRequest};
 use types::Diagnostic;
 
+pub use types::LambdaRequest;
+
 /// Error type that lambdas may result in
 pub type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 
@@ -68,42 +72,17 @@ impl Config {
     }
 }
 
-/// A trait describing an asynchronous function `A` to `B`.
-pub trait Handler<A, B> {
-    /// Errors returned by this handler.
-    type Error;
-    /// Response of this handler.
-    type Fut: Future<Output = Result<B, Self::Error>>;
-    /// Handle the incoming event.
-    fn call(&mut self, event: A, context: Context) -> Self::Fut;
-}
-
-/// Returns a new [`HandlerFn`] with the given closure.
-///
-/// [`HandlerFn`]: struct.HandlerFn.html
-pub fn handler_fn<F>(f: F) -> HandlerFn<F> {
-    HandlerFn { f }
+/// Wraps a function that takes 2 arguments into one that only takes a [`LambdaRequest`].
+fn handler_wrapper<A, Fut>(f: impl Fn(A, Context) -> Fut) -> impl Fn(LambdaRequest<A>) -> Fut {
+    move |req| f(req.event, req.context)
 }
 
-/// A [`Handler`] implemented by a closure.
-///
-/// [`Handler`]: trait.Handler.html
-#[derive(Clone, Debug)]
-pub struct HandlerFn<F> {
-    f: F,
-}
-
-impl<F, A, B, Error, Fut> Handler<A, B> for HandlerFn<F>
+/// Return a new [`ServiceFn`] with a closure that takes an event and context as separate arguments.
+pub fn handler_fn<A, F, Fut>(f: F) -> ServiceFn<impl Fn(LambdaRequest<A>) -> Fut>
 where
     F: Fn(A, Context) -> Fut,
-    Fut: Future<Output = Result<B, Error>>,
-    Error: Into<Box<dyn std::error::Error + Send + Sync + 'static>> + fmt::Display,
 {
-    type Error = Error;
-    type Fut = Fut;
-    fn call(&mut self, req: A, ctx: Context) -> Self::Fut {
-        (self.f)(req, ctx)
-    }
+    service_fn(handler_wrapper(f))
 }
 
 #[non_exhaustive]
@@ -128,9 +107,9 @@ impl Runtime {
 impl<C> Runtime<C>
 where
     C: Service<http::Uri> + Clone + Send + Sync + Unpin + 'static,
-    <C as Service<http::Uri>>::Future: Unpin + Send,
-    <C as Service<http::Uri>>::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
-    <C as Service<http::Uri>>::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
+    C::Future: Unpin + Send,
+    C::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    C::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
 {
     pub async fn run<F, A, B>(
         &self,
@@ -139,9 +118,9 @@ where
         config: &Config,
     ) -> Result<(), Error>
     where
-        F: Handler<A, B>,
-        <F as Handler<A, B>>::Fut: Future<Output = Result<B, <F as Handler<A, B>>::Error>>,
-        <F as Handler<A, B>>::Error: fmt::Display,
+        F: Service<LambdaRequest<A>>,
+        F::Future: Future<Output = Result<B, F::Error>>,
+        F::Error: fmt::Display,
         A: for<'de> Deserialize<'de>,
         B: Serialize,
     {
@@ -162,7 +141,12 @@ where
             env::set_var("_X_AMZN_TRACE_ID", xray_trace_id);
 
             let request_id = &ctx.request_id.clone();
-            let task = panic::catch_unwind(panic::AssertUnwindSafe(|| handler.call(body, ctx)));
+            let task = panic::catch_unwind(panic::AssertUnwindSafe(|| {
+                handler.call(LambdaRequest {
+                    event: body,
+                    context: ctx,
+                })
+            }));
 
             let req = match task {
                 Ok(response) => match response.await {
@@ -217,16 +201,16 @@ struct RuntimeBuilder<C: Service<http::Uri> = hyper::client::HttpConnector> {
 impl<C> RuntimeBuilder<C>
 where
     C: Service<http::Uri> + Clone + Send + Sync + Unpin + 'static,
-    <C as Service<http::Uri>>::Future: Unpin + Send,
-    <C as Service<http::Uri>>::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
-    <C as Service<http::Uri>>::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
+    C::Future: Unpin + Send,
+    C::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    C::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
 {
     pub fn with_connector<C2>(self, connector: C2) -> RuntimeBuilder<C2>
     where
         C2: Service<http::Uri> + Clone + Send + Sync + Unpin + 'static,
-        <C2 as Service<http::Uri>>::Future: Unpin + Send,
-        <C2 as Service<http::Uri>>::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
-        <C2 as Service<http::Uri>>::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
+        C2::Future: Unpin + Send,
+        C2::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+        C2::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
     {
         RuntimeBuilder {
             connector,
@@ -262,9 +246,9 @@ fn test_builder() {
 fn incoming<C>(client: &Client<C>) -> impl Stream<Item = Result<http::Response<hyper::Body>, Error>> + Send + '_
 where
     C: Service<http::Uri> + Clone + Send + Sync + Unpin + 'static,
-    <C as Service<http::Uri>>::Future: Unpin + Send,
-    <C as Service<http::Uri>>::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
-    <C as Service<http::Uri>>::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
+    C::Future: Unpin + Send,
+    C::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
+    C::Response: AsyncRead + AsyncWrite + Connection + Unpin + Send + 'static,
 {
     async_stream::stream! {
         loop {
@@ -297,9 +281,9 @@ where
 /// ```
 pub async fn run<A, B, F>(handler: F) -> Result<(), Error>
 where
-    F: Handler<A, B>,
-    <F as Handler<A, B>>::Fut: Future<Output = Result<B, <F as Handler<A, B>>::Error>>,
-    <F as Handler<A, B>>::Error: fmt::Display,
+    F: Service<LambdaRequest<A>>,
+    F::Future: Future<Output = Result<B, F::Error>>,
+    F::Error: fmt::Display,
     A: for<'de> Deserialize<'de>,
     B: Serialize,
 {
diff --git a/lambda-runtime/src/types.rs b/lambda-runtime/src/types.rs
index ad894971..4cfbd1aa 100644
--- a/lambda-runtime/src/types.rs
+++ b/lambda-runtime/src/types.rs
@@ -148,6 +148,15 @@ impl TryFrom<HeaderMap> for Context {
     }
 }
 
+/// Incoming Lambda request containing the event payload and context.
+#[derive(Clone, Debug)]
+pub struct LambdaRequest<T> {
+    /// Event payload.
+    pub event: T,
+    /// Invocation context.
+    pub context: Context,
+}
+
 #[cfg(test)]
 mod test {
     use super::*;