Add assistant middleware inheritance option

Author: Cr1stal

slack_bolt/app/app.py

@@ -683,19 +683,26 @@ def middleware_func(logger, body, next):
                 self._middleware_list.append(middleware)
                 if isinstance(middleware, Assistant) and middleware.thread_context_store is not None:
                     self._assistant_thread_context_store = middleware.thread_context_store
+                elif not isinstance(middleware, Assistant):
+                    self._inherit_app_middleware_for_assistants(middleware)
             elif callable(middleware_or_callable):
-                self._middleware_list.append(
-                    CustomMiddleware(
-                        app_name=self.name,
-                        func=middleware_or_callable,
-                        base_logger=self._base_logger,
-                    )
+                middleware = CustomMiddleware(
+                    app_name=self.name,
+                    func=middleware_or_callable,
+                    base_logger=self._base_logger,
                 )
+                self._middleware_list.append(middleware)
+                self._inherit_app_middleware_for_assistants(middleware)
                 return middleware_or_callable
             else:
                 raise BoltError(f"Unexpected type for a middleware ({type(middleware_or_callable)})")
         return None
 
+    def _inherit_app_middleware_for_assistants(self, middleware: Middleware) -> None:
+        for registered_middleware in self._middleware_list[:-1]:
+            if isinstance(registered_middleware, Assistant):
+                registered_middleware.inherit_app_middleware(middleware)
+
     # -------------------------
     # AI Agents & Assistants
 

slack_bolt/app/async_app.py

@@ -710,19 +710,26 @@ async def middleware_func(logger, body, next):
                 self._async_middleware_list.append(middleware)
                 if isinstance(middleware, AsyncAssistant) and middleware.thread_context_store is not None:
                     self._assistant_thread_context_store = middleware.thread_context_store
+                elif not isinstance(middleware, AsyncAssistant):
+                    self._inherit_app_middleware_for_assistants(middleware)
             elif callable(middleware_or_callable):
-                self._async_middleware_list.append(
-                    AsyncCustomMiddleware(
-                        app_name=self.name,
-                        func=middleware_or_callable,
-                        base_logger=self._base_logger,
-                    )
+                middleware = AsyncCustomMiddleware(
+                    app_name=self.name,
+                    func=middleware_or_callable,
+                    base_logger=self._base_logger,
                 )
+                self._async_middleware_list.append(middleware)
+                self._inherit_app_middleware_for_assistants(middleware)
                 return middleware_or_callable
             else:
                 raise BoltError(f"Unexpected type for a middleware ({type(middleware_or_callable)})")
         return None
 
+    def _inherit_app_middleware_for_assistants(self, middleware: AsyncMiddleware) -> None:
+        for registered_middleware in self._async_middleware_list[:-1]:
+            if isinstance(registered_middleware, AsyncAssistant):
+                registered_middleware.inherit_app_middleware(middleware)
+
     def assistant(self, assistant: AsyncAssistant) -> Optional[Callable]:
         return self.middleware(assistant)
 

slack_bolt/middleware/assistant/assistant.py

@@ -1,7 +1,7 @@
 import logging
 from functools import wraps
 from logging import Logger
-from typing import List, Optional, Union, Callable
+from typing import List, Optional, Union, Callable, Tuple
 
 from slack_bolt.context.save_thread_context import SaveThreadContext
 from slack_bolt.context.assistant.thread_context_store.store import AssistantThreadContextStore
@@ -42,16 +42,25 @@ def __init__(
         app_name: str = "assistant",
         thread_context_store: Optional[AssistantThreadContextStore] = None,
         logger: Optional[logging.Logger] = None,
+        auto_inherit_app_middleware: bool = False,
     ):
         self.app_name = app_name
         self.thread_context_store = thread_context_store
         self.base_logger = logger
+        self.auto_inherit_app_middleware = auto_inherit_app_middleware
+        self._inherited_app_middleware: List[Middleware] = []
 
         self._thread_started_listeners = None
         self._thread_context_changed_listeners = None
         self._user_message_listeners = None
         self._bot_message_listeners = None
 
+    def inherit_app_middleware(self, middleware: Middleware) -> None:
+        if self.auto_inherit_app_middleware is False:
+            return
+
+        self._inherited_app_middleware.append(middleware)
+
     def thread_started(
         self,
         *args,
@@ -237,7 +246,11 @@ def process(  # type: ignore[return]
             if listeners is not None:
                 for listener in listeners:
                     if listener.matches(req=req, resp=resp):
-                        middleware_resp, next_was_not_called = listener.run_middleware(req=req, resp=resp)
+                        middleware_resp, next_was_not_called = self._run_middleware(
+                            listener=listener,
+                            req=req,
+                            resp=resp,
+                        )
                         if next_was_not_called:
                             if middleware_resp is not None:
                                 return middleware_resp
@@ -258,6 +271,33 @@ def process(  # type: ignore[return]
 
         next()
 
+    def _run_middleware(
+        self,
+        *,
+        listener: Listener,
+        req: BoltRequest,
+        resp: BoltResponse,
+    ) -> Tuple[Optional[BoltResponse], bool]:
+        middleware = list(listener.middleware)
+        if len(self._inherited_app_middleware) > 0:
+            insertion_index = 1 if len(middleware) > 0 and isinstance(middleware[0], AttachingConversationKwargs) else 0
+            middleware = [
+                *middleware[:insertion_index],
+                *self._inherited_app_middleware,
+                *middleware[insertion_index:],
+            ]
+
+        for m in middleware:
+            middleware_state = {"next_called": False}
+
+            def next_():
+                middleware_state["next_called"] = True
+
+            resp = m.process(req=req, resp=resp, next=next_)  # type: ignore[assignment]
+            if not middleware_state["next_called"]:
+                return resp, True
+        return resp, False
+
     def build_listener(
         self,
         listener_or_functions: Union[Listener, Callable, List[Callable]],
@@ -271,8 +311,10 @@ def build_listener(
         if isinstance(listener_or_functions, Listener):
             return listener_or_functions
         elif isinstance(listener_or_functions, list):
-            middleware = middleware if middleware else []
-            middleware.insert(0, AttachingConversationKwargs(self.thread_context_store))
+            middleware = [
+                AttachingConversationKwargs(self.thread_context_store),
+                *(middleware if middleware else []),
+            ]
             functions = listener_or_functions
             ack_function = functions.pop(0)
 

slack_bolt/middleware/assistant/async_assistant.py

@@ -1,7 +1,7 @@
 import logging
 from functools import wraps
 from logging import Logger
-from typing import List, Optional, Union, Callable, Awaitable
+from typing import List, Optional, Union, Callable, Awaitable, Tuple
 
 from slack_bolt.context.save_thread_context.async_save_thread_context import AsyncSaveThreadContext
 from slack_bolt.context.assistant.thread_context_store.async_store import AsyncAssistantThreadContextStore
@@ -42,16 +42,25 @@ def __init__(
         app_name: str = "assistant",
         thread_context_store: Optional[AsyncAssistantThreadContextStore] = None,
         logger: Optional[logging.Logger] = None,
+        auto_inherit_app_middleware: bool = False,
     ):
         self.app_name = app_name
         self.thread_context_store = thread_context_store
         self.base_logger = logger
+        self.auto_inherit_app_middleware = auto_inherit_app_middleware
+        self._inherited_app_middleware: List[AsyncMiddleware] = []
 
         self._thread_started_listeners = None
         self._thread_context_changed_listeners = None
         self._user_message_listeners = None
         self._bot_message_listeners = None
 
+    def inherit_app_middleware(self, middleware: AsyncMiddleware) -> None:
+        if self.auto_inherit_app_middleware is False:
+            return
+
+        self._inherited_app_middleware.append(middleware)
+
     def thread_started(
         self,
         *args,
@@ -268,7 +277,11 @@ async def async_process(  # type: ignore[return]
             if listeners is not None:
                 for listener in listeners:
                     if listener is not None and await listener.async_matches(req=req, resp=resp):
-                        middleware_resp, next_was_not_called = await listener.run_async_middleware(req=req, resp=resp)
+                        middleware_resp, next_was_not_called = await self._run_middleware(
+                            listener=listener,
+                            req=req,
+                            resp=resp,
+                        )
                         if next_was_not_called:
                             if middleware_resp is not None:
                                 return middleware_resp
@@ -289,6 +302,33 @@ async def async_process(  # type: ignore[return]
 
         await next()
 
+    async def _run_middleware(
+        self,
+        *,
+        listener: AsyncListener,
+        req: AsyncBoltRequest,
+        resp: BoltResponse,
+    ) -> Tuple[Optional[BoltResponse], bool]:
+        middleware = list(listener.middleware)
+        if len(self._inherited_app_middleware) > 0:
+            insertion_index = 1 if len(middleware) > 0 and isinstance(middleware[0], AsyncAttachingConversationKwargs) else 0
+            middleware = [
+                *middleware[:insertion_index],
+                *self._inherited_app_middleware,
+                *middleware[insertion_index:],
+            ]
+
+        for m in middleware:
+            middleware_state = {"next_called": False}
+
+            async def next_():
+                middleware_state["next_called"] = True
+
+            resp = await m.async_process(req=req, resp=resp, next=next_)  # type: ignore[assignment]
+            if not middleware_state["next_called"]:
+                return resp, True
+        return resp, False
+
     def build_listener(
         self,
         listener_or_functions: Union[AsyncListener, Callable, List[Callable]],
@@ -302,8 +342,10 @@ def build_listener(
         if isinstance(listener_or_functions, AsyncListener):
             return listener_or_functions
         elif isinstance(listener_or_functions, list):
-            middleware = middleware if middleware else []
-            middleware.insert(0, AsyncAttachingConversationKwargs(self.thread_context_store))
+            middleware = [
+                AsyncAttachingConversationKwargs(self.thread_context_store),
+                *(middleware if middleware else []),
+            ]
             functions = listener_or_functions
             ack_function = functions.pop(0)