diff --git a/docs/api-docs/slack_bolt/app/app.html b/docs/api-docs/slack_bolt/app/app.html
index 9490358d6..3e01431fc 100644
--- a/docs/api-docs/slack_bolt/app/app.html
+++ b/docs/api-docs/slack_bolt/app/app.html
@@ -539,15 +539,18 @@ <h1 class="title">Module <code>slack_bolt.app.app</code></h1>
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                         if self._raise_error_for_unhandled_request is True:
-                            self._listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                self._listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -590,14 +593,17 @@ <h1 class="title">Module <code>slack_bolt.app.app</code></h1>
             if resp is None:
                 resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
             if self._raise_error_for_unhandled_request is True:
-                self._listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    self._listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
         except Exception as error:
@@ -1995,15 +2001,18 @@ <h2 id="args">Args</h2>
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                         if self._raise_error_for_unhandled_request is True:
-                            self._listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                self._listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -2046,14 +2055,17 @@ <h2 id="args">Args</h2>
             if resp is None:
                 resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
             if self._raise_error_for_unhandled_request is True:
-                self._listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    self._listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
         except Exception as error:
@@ -3274,15 +3286,18 @@ <h2 id="returns">Returns</h2>
                     # This should not be an intentional handling in usual use cases.
                     resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                     if self._raise_error_for_unhandled_request is True:
-                        self._listener_runner.listener_error_handler.handle(
-                            error=BoltUnhandledRequestError(
+                        try:
+                            raise BoltUnhandledRequestError(
                                 request=req,
                                 current_response=resp,
                                 last_global_middleware_name=middleware.name,
-                            ),
-                            request=req,
-                            response=resp,
-                        )
+                            )
+                        except BoltUnhandledRequestError as e:
+                            self._listener_runner.listener_error_handler.handle(
+                                error=e,
+                                request=req,
+                                response=resp,
+                            )
                         return resp
                     self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                     return resp
@@ -3325,14 +3340,17 @@ <h2 id="returns">Returns</h2>
         if resp is None:
             resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
         if self._raise_error_for_unhandled_request is True:
-            self._listener_runner.listener_error_handler.handle(
-                error=BoltUnhandledRequestError(
+            try:
+                raise BoltUnhandledRequestError(
                     request=req,
                     current_response=resp,
-                ),
-                request=req,
-                response=resp,
-            )
+                )
+            except BoltUnhandledRequestError as e:
+                self._listener_runner.listener_error_handler.handle(
+                    error=e,
+                    request=req,
+                    response=resp,
+                )
             return resp
         return self._handle_unmatched_requests(req, resp)
     except Exception as error:
diff --git a/docs/api-docs/slack_bolt/app/async_app.html b/docs/api-docs/slack_bolt/app/async_app.html
index f373a32e6..ecb30728e 100644
--- a/docs/api-docs/slack_bolt/app/async_app.html
+++ b/docs/api-docs/slack_bolt/app/async_app.html
@@ -563,15 +563,18 @@ <h1 class="title">Module <code>slack_bolt.app.async_app</code></h1>
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                         if self._raise_error_for_unhandled_request is True:
-                            await self._async_listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                await self._async_listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -617,14 +620,17 @@ <h1 class="title">Module <code>slack_bolt.app.async_app</code></h1>
             if resp is None:
                 resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
             if self._raise_error_for_unhandled_request is True:
-                await self._async_listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    await self._async_listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
 
@@ -1915,15 +1921,18 @@ <h2 id="args">Args</h2>
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                         if self._raise_error_for_unhandled_request is True:
-                            await self._async_listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                await self._async_listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -1969,14 +1978,17 @@ <h2 id="args">Args</h2>
             if resp is None:
                 resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
             if self._raise_error_for_unhandled_request is True:
-                await self._async_listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    await self._async_listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
 
@@ -2952,15 +2964,18 @@ <h2 id="returns">Returns</h2>
                     # This should not be an intentional handling in usual use cases.
                     resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                     if self._raise_error_for_unhandled_request is True:
-                        await self._async_listener_runner.listener_error_handler.handle(
-                            error=BoltUnhandledRequestError(
+                        try:
+                            raise BoltUnhandledRequestError(
                                 request=req,
                                 current_response=resp,
                                 last_global_middleware_name=middleware.name,
-                            ),
-                            request=req,
-                            response=resp,
-                        )
+                            )
+                        except BoltUnhandledRequestError as e:
+                            await self._async_listener_runner.listener_error_handler.handle(
+                                error=e,
+                                request=req,
+                                response=resp,
+                            )
                         return resp
                     self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                     return resp
@@ -3006,14 +3021,17 @@ <h2 id="returns">Returns</h2>
         if resp is None:
             resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
         if self._raise_error_for_unhandled_request is True:
-            await self._async_listener_runner.listener_error_handler.handle(
-                error=BoltUnhandledRequestError(
+            try:
+                raise BoltUnhandledRequestError(
                     request=req,
                     current_response=resp,
-                ),
-                request=req,
-                response=resp,
-            )
+                )
+            except BoltUnhandledRequestError as e:
+                await self._async_listener_runner.listener_error_handler.handle(
+                    error=e,
+                    request=req,
+                    response=resp,
+                )
             return resp
         return self._handle_unmatched_requests(req, resp)
 
diff --git a/docs/api-docs/slack_bolt/app/index.html b/docs/api-docs/slack_bolt/app/index.html
index 4175c54ac..6604ab567 100644
--- a/docs/api-docs/slack_bolt/app/index.html
+++ b/docs/api-docs/slack_bolt/app/index.html
@@ -588,15 +588,18 @@ <h2 id="args">Args</h2>
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                         if self._raise_error_for_unhandled_request is True:
-                            self._listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                self._listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -639,14 +642,17 @@ <h2 id="args">Args</h2>
             if resp is None:
                 resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
             if self._raise_error_for_unhandled_request is True:
-                self._listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    self._listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
         except Exception as error:
@@ -1867,15 +1873,18 @@ <h2 id="returns">Returns</h2>
                     # This should not be an intentional handling in usual use cases.
                     resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                     if self._raise_error_for_unhandled_request is True:
-                        self._listener_runner.listener_error_handler.handle(
-                            error=BoltUnhandledRequestError(
+                        try:
+                            raise BoltUnhandledRequestError(
                                 request=req,
                                 current_response=resp,
                                 last_global_middleware_name=middleware.name,
-                            ),
-                            request=req,
-                            response=resp,
-                        )
+                            )
+                        except BoltUnhandledRequestError as e:
+                            self._listener_runner.listener_error_handler.handle(
+                                error=e,
+                                request=req,
+                                response=resp,
+                            )
                         return resp
                     self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                     return resp
@@ -1918,14 +1927,17 @@ <h2 id="returns">Returns</h2>
         if resp is None:
             resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
         if self._raise_error_for_unhandled_request is True:
-            self._listener_runner.listener_error_handler.handle(
-                error=BoltUnhandledRequestError(
+            try:
+                raise BoltUnhandledRequestError(
                     request=req,
                     current_response=resp,
-                ),
-                request=req,
-                response=resp,
-            )
+                )
+            except BoltUnhandledRequestError as e:
+                self._listener_runner.listener_error_handler.handle(
+                    error=e,
+                    request=req,
+                    response=resp,
+                )
             return resp
         return self._handle_unmatched_requests(req, resp)
     except Exception as error:
diff --git a/docs/api-docs/slack_bolt/async_app.html b/docs/api-docs/slack_bolt/async_app.html
index e6b693440..902e18dfe 100644
--- a/docs/api-docs/slack_bolt/async_app.html
+++ b/docs/api-docs/slack_bolt/async_app.html
@@ -718,15 +718,18 @@ <h2 id="args">Args</h2>
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                         if self._raise_error_for_unhandled_request is True:
-                            await self._async_listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                await self._async_listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -772,14 +775,17 @@ <h2 id="args">Args</h2>
             if resp is None:
                 resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
             if self._raise_error_for_unhandled_request is True:
-                await self._async_listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    await self._async_listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
 
@@ -1755,15 +1761,18 @@ <h2 id="returns">Returns</h2>
                     # This should not be an intentional handling in usual use cases.
                     resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                     if self._raise_error_for_unhandled_request is True:
-                        await self._async_listener_runner.listener_error_handler.handle(
-                            error=BoltUnhandledRequestError(
+                        try:
+                            raise BoltUnhandledRequestError(
                                 request=req,
                                 current_response=resp,
                                 last_global_middleware_name=middleware.name,
-                            ),
-                            request=req,
-                            response=resp,
-                        )
+                            )
+                        except BoltUnhandledRequestError as e:
+                            await self._async_listener_runner.listener_error_handler.handle(
+                                error=e,
+                                request=req,
+                                response=resp,
+                            )
                         return resp
                     self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                     return resp
@@ -1809,14 +1818,17 @@ <h2 id="returns">Returns</h2>
         if resp is None:
             resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
         if self._raise_error_for_unhandled_request is True:
-            await self._async_listener_runner.listener_error_handler.handle(
-                error=BoltUnhandledRequestError(
+            try:
+                raise BoltUnhandledRequestError(
                     request=req,
                     current_response=resp,
-                ),
-                request=req,
-                response=resp,
-            )
+                )
+            except BoltUnhandledRequestError as e:
+                await self._async_listener_runner.listener_error_handler.handle(
+                    error=e,
+                    request=req,
+                    response=resp,
+                )
             return resp
         return self._handle_unmatched_requests(req, resp)
 
diff --git a/docs/api-docs/slack_bolt/error/index.html b/docs/api-docs/slack_bolt/error/index.html
index 827fecc42..fcc4de3fe 100644
--- a/docs/api-docs/slack_bolt/error/index.html
+++ b/docs/api-docs/slack_bolt/error/index.html
@@ -51,7 +51,10 @@ <h1 class="title">Module <code>slack_bolt.error</code></h1>
         self.request = request
         self.body = request.body if request is not None else {}
         self.current_response = current_response
-        self.last_global_middleware_name = last_global_middleware_name</code></pre>
+        self.last_global_middleware_name = last_global_middleware_name
+
+    def __str__(self) -&gt; str:
+        return &#34;unhandled request error&#34;</code></pre>
 </details>
 </section>
 <section>
@@ -112,7 +115,10 @@ <h3>Subclasses</h3>
         self.request = request
         self.body = request.body if request is not None else {}
         self.current_response = current_response
-        self.last_global_middleware_name = last_global_middleware_name</code></pre>
+        self.last_global_middleware_name = last_global_middleware_name
+
+    def __str__(self) -&gt; str:
+        return &#34;unhandled request error&#34;</code></pre>
 </details>
 <h3>Ancestors</h3>
 <ul class="hlist">
diff --git a/docs/api-docs/slack_bolt/index.html b/docs/api-docs/slack_bolt/index.html
index fa7283542..3e741d194 100644
--- a/docs/api-docs/slack_bolt/index.html
+++ b/docs/api-docs/slack_bolt/index.html
@@ -726,15 +726,18 @@ <h2 id="args">Args</h2>
                         # This should not be an intentional handling in usual use cases.
                         resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                         if self._raise_error_for_unhandled_request is True:
-                            self._listener_runner.listener_error_handler.handle(
-                                error=BoltUnhandledRequestError(
+                            try:
+                                raise BoltUnhandledRequestError(
                                     request=req,
                                     current_response=resp,
                                     last_global_middleware_name=middleware.name,
-                                ),
-                                request=req,
-                                response=resp,
-                            )
+                                )
+                            except BoltUnhandledRequestError as e:
+                                self._listener_runner.listener_error_handler.handle(
+                                    error=e,
+                                    request=req,
+                                    response=resp,
+                                )
                             return resp
                         self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                         return resp
@@ -777,14 +780,17 @@ <h2 id="args">Args</h2>
             if resp is None:
                 resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
             if self._raise_error_for_unhandled_request is True:
-                self._listener_runner.listener_error_handler.handle(
-                    error=BoltUnhandledRequestError(
+                try:
+                    raise BoltUnhandledRequestError(
                         request=req,
                         current_response=resp,
-                    ),
-                    request=req,
-                    response=resp,
-                )
+                    )
+                except BoltUnhandledRequestError as e:
+                    self._listener_runner.listener_error_handler.handle(
+                        error=e,
+                        request=req,
+                        response=resp,
+                    )
                 return resp
             return self._handle_unmatched_requests(req, resp)
         except Exception as error:
@@ -2005,15 +2011,18 @@ <h2 id="returns">Returns</h2>
                     # This should not be an intentional handling in usual use cases.
                     resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;no next() calls in middleware&#34;})
                     if self._raise_error_for_unhandled_request is True:
-                        self._listener_runner.listener_error_handler.handle(
-                            error=BoltUnhandledRequestError(
+                        try:
+                            raise BoltUnhandledRequestError(
                                 request=req,
                                 current_response=resp,
                                 last_global_middleware_name=middleware.name,
-                            ),
-                            request=req,
-                            response=resp,
-                        )
+                            )
+                        except BoltUnhandledRequestError as e:
+                            self._listener_runner.listener_error_handler.handle(
+                                error=e,
+                                request=req,
+                                response=resp,
+                            )
                         return resp
                     self._framework_logger.warning(warning_unhandled_by_global_middleware(middleware.name, req))
                     return resp
@@ -2056,14 +2065,17 @@ <h2 id="returns">Returns</h2>
         if resp is None:
             resp = BoltResponse(status=404, body={&#34;error&#34;: &#34;unhandled request&#34;})
         if self._raise_error_for_unhandled_request is True:
-            self._listener_runner.listener_error_handler.handle(
-                error=BoltUnhandledRequestError(
+            try:
+                raise BoltUnhandledRequestError(
                     request=req,
                     current_response=resp,
-                ),
-                request=req,
-                response=resp,
-            )
+                )
+            except BoltUnhandledRequestError as e:
+                self._listener_runner.listener_error_handler.handle(
+                    error=e,
+                    request=req,
+                    response=resp,
+                )
             return resp
         return self._handle_unmatched_requests(req, resp)
     except Exception as error:
diff --git a/docs/api-docs/slack_bolt/version.html b/docs/api-docs/slack_bolt/version.html
index a55652360..78c22351c 100644
--- a/docs/api-docs/slack_bolt/version.html
+++ b/docs/api-docs/slack_bolt/version.html
@@ -28,7 +28,7 @@ <h1 class="title">Module <code>slack_bolt.version</code></h1>
 <span>Expand source code</span>
 </summary>
 <pre><code class="python">&#34;&#34;&#34;Check the latest version at https://pypi.org/project/slack-bolt/&#34;&#34;&#34;
-__version__ = &#34;1.17.1&#34;</code></pre>
+__version__ = &#34;1.17.2&#34;</code></pre>
 </details>
 </section>
 <section>
diff --git a/setup.py b/setup.py
index 470188554..e56410465 100755
--- a/setup.py
+++ b/setup.py
@@ -58,7 +58,7 @@
     ),
     include_package_data=True,  # MANIFEST.in
     install_requires=[
-        "slack_sdk>=3.21.1,<4",
+        "slack_sdk>=3.21.2,<4",
     ],
     setup_requires=["pytest-runner==5.2"],
     tests_require=async_test_dependencies,
diff --git a/slack_bolt/version.py b/slack_bolt/version.py
index 02de47405..5b4966f0c 100644
--- a/slack_bolt/version.py
+++ b/slack_bolt/version.py
@@ -1,2 +1,2 @@
 """Check the latest version at https://pypi.org/project/slack-bolt/"""
-__version__ = "1.17.1"
+__version__ = "1.17.2"