fix: dispatch email channel when force_sync=True and celery is enabled

When `force_sync=True` is passed to `send_notification_internal`, the
notification row was created and SSE events fired, but email (and any
other async channel) was never dispatched because the channel plugins are
only registered when celery tasks are enabled. This meant tool-request
notifications — which the service layer explicitly forces to sync so the
client gets a response ID — would not deliver email to admins.

Changes:
- Add `_dispatch_notification_via_channels` to `NotificationManager` that
  marks the row dispatched and then calls `_dispatch_notification_to_users`,
  mirroring the pattern in `dispatch_pending_notifications_via_channels`.
- Call it inside `send_notification_internal` when `force_sync=True` and
  celery is enabled (i.e. channels are registered).
- Deduplicate the sync/async branching that was duplicated between
  `NotificationService.send_notification_internal` and the manager: the
  service now delegates directly to the manager.
- Make `contact_email` and `notification_settings_url` on
  `NotificationContext` `Optional` (the builder already produced `None`
  for both when config is absent; templates already guard with `{% if %}`).
- Add unit test asserting email channel fires on `force_sync=True`.
- Add integration test with mock SMTP verifying end-to-end email delivery
  for tool-request submissions when celery tasks are enabled.

Author: arash77

lib/galaxy/managers/notification.py

@@ -194,8 +194,9 @@ def send_notification_internal(
     ) -> Union[NotificationCreatedResponse, AsyncTaskResultSummary]:
         """Sends a notification to a list of recipients (users, groups or roles).
 
-        If `force_sync` is set to `True`, the notification recipients will be processed synchronously instead of
-        in a background task.
+        If `force_sync` is set to `True`, recipient association creation and any
+        configured channel delivery will be processed synchronously instead of in a
+        background task.
 
         Note: This function is meant for internal use from other callers that don't need to check sender permissions.
         """
@@ -208,11 +209,22 @@ def send_notification_internal(
             return async_task_summary(result)
 
         notification, recipient_user_count = self.send_notification_to_recipients(request)
+        if notification is None:
+            raise RuntimeError("Expected notification to be created before delivery.")
+        if self.can_send_notifications_async and force_sync:
+            self._dispatch_notification_via_channels(notification)
         return NotificationCreatedResponse(
             total_notifications_sent=recipient_user_count,
             notification=NotificationResponse.model_validate(notification),
         )
 
+    def _dispatch_notification_via_channels(self, notification: Notification) -> None:
+        # Mark dispatched before delivery — same trade-off as dispatch_pending_notifications_via_channels:
+        # a transient SMTP failure leaves the row marked and won't be retried by the beat task.
+        notification.dispatched = True
+        self.sa_session.commit()
+        self._dispatch_notification_to_users(notification)
+
     def _create_associations(self, notification: Notification, users: list[User]) -> int:
         success_count = 0
         for user in users:
@@ -723,9 +735,9 @@ class NotificationContext(BaseModel):
     user_email: str
     date: str
     hostname: str
-    contact_email: str
+    contact_email: Optional[str] = None
     variant: str
-    notification_settings_url: str
+    notification_settings_url: Optional[str] = None
     content: AnyNotificationContent
     workflow_name: Optional[str] = None
     galaxy_url: Optional[str] = None

lib/galaxy/webapps/galaxy/services/notifications.py

@@ -9,8 +9,6 @@
     Union,
 )
 
-from galaxy.celery.helpers import async_task_summary
-from galaxy.celery.tasks import send_notification_to_recipients_async
 from galaxy.config import GalaxyAppConfiguration
 from galaxy.exceptions import (
     AdminRequiredException,
@@ -177,16 +175,7 @@ def send_notification_internal(
 
         Note: This function is meant for internal use from other services that don't need to check sender permissions.
         """
-        if self.notification_manager.can_send_notifications_async and not force_sync:
-            result = send_notification_to_recipients_async.delay(request)
-            summary = async_task_summary(result)
-            return summary
-
-        notification, recipient_user_count = self.notification_manager.send_notification_to_recipients(request)
-        return NotificationCreatedResponse(
-            total_notifications_sent=recipient_user_count,
-            notification=NotificationResponse.model_validate(notification),
-        )
+        return self.notification_manager.send_notification_internal(request, force_sync=force_sync)
 
     def broadcast(
         self, sender_context: ProvidesUserContext, payload: BroadcastNotificationCreateRequest

test/integration/test_tool_request_form.py

@@ -1,5 +1,9 @@
 """Integration tests for the tool-request-form feature (routed via POST /api/notifications)."""
 
+import json
+import os
+from typing import ClassVar
+
 from galaxy_test.base.api_util import ADMIN_TEST_USER
 from galaxy_test.driver.integration_util import IntegrationTestCase
 
@@ -210,6 +214,48 @@ def test_workflow_install_request_with_tool_names(self):
         assert len(content["tool_names"]) == 2
 
 
+class TestToolRequestFormEmailDeliveryIntegration(ToolRequestFormIntegrationBase):
+    email_directory: ClassVar[str]
+
+    @classmethod
+    def handle_galaxy_config_kwds(cls, config):
+        super().handle_galaxy_config_kwds(config)
+        cls.email_directory = cls._test_driver.mkdtemp()
+        config["enable_celery_tasks"] = True
+        config["email_from"] = "galaxy-no-reply@example.com"
+        config["smtp_server"] = f"mock_emails_to_path://{cls.email_directory}/email.json"
+
+    def test_submission_sends_admin_email_when_force_sync_is_required(self):
+        """Tool requests should still deliver email notifications when the API forces synchronous processing."""
+        user = self._setup_user("tool_request_email_delivery@galaxy.test")
+        with self._different_user(user["email"]):
+            update_request = {
+                "preferences": {
+                    "tool_request": {
+                        "enabled": True,
+                        "channels": {"push": True, "email": False},
+                    }
+                }
+            }
+            update_response = self._put("notifications/preferences", data=update_request, json=True)
+            self._assert_status_code_is_ok(update_response)
+
+            response = self._post("notifications", data=TOOL_REQUEST_NOTIFICATION_BODY, json=True)
+            self._assert_status_code_is(response, 200)
+
+        with open(os.path.join(self.email_directory, "email.json")) as f:
+            email = json.loads(f.read())
+
+        assert email["from"] == "galaxy-no-reply@example.com"
+        assert email["to"] == ADMIN_TEST_USER
+        assert email["subject"] == "[Galaxy] Tool installation request: FastQC"
+        assert user["email"] in email["body"]
+        assert "Quality control tool for high-throughput sequencing data." in email["body"]
+        assert email["html"] is not None
+        assert "Would be great for the genomics team." in email["html"]
+        assert "/user/notifications" in email["html"]
+
+
 class TestToolRequestFormDisabledIntegration(IntegrationTestCase):
     """Tests for when the tool request form feature is disabled."""
 

test/unit/app/managers/test_NotificationManager.py

@@ -24,13 +24,15 @@
     Role,
     User,
 )
+from galaxy.schema.fields import Security
 from galaxy.schema.notifications import (
     BroadcastNotificationContent,
     BroadcastNotificationCreateRequest,
     NotificationBroadcastUpdateRequest,
     NotificationCategorySettings,
     NotificationChannelSettings,
     NotificationCreateData,
+    NotificationCreatedResponse,
     NotificationCreateRequest,
     NotificationRecipients,
     NotificationVariant,
@@ -39,6 +41,7 @@
     UserNotificationPreferences,
     UserNotificationUpdateRequest,
 )
+from galaxy.security.idencoding import IdEncodingHelper
 from .base import BaseTestCase
 
 
@@ -469,6 +472,24 @@ def validate_send_email(frm, to, subject, body, config, html=None):
             mock_send_mail.assert_called_once()
             assert len(emails_sent) == 1
 
+    def test_force_sync_dispatches_email_channel_when_async_is_enabled(self):
+        user = self._create_test_user()
+        Security.security = IdEncodingHelper(id_secret="testing")
+
+        request = NotificationCreateRequest(
+            recipients=NotificationRecipients.model_construct(user_ids=[user.id]),
+            notification=NotificationCreateData(**self._default_test_notification_data()),
+            galaxy_url="https://test.galaxy.url",
+        )
+
+        with patch("galaxy.util.send_mail") as mock_send_mail:
+            response = self.notification_manager.send_notification_internal(request, force_sync=True)
+
+        assert isinstance(response, NotificationCreatedResponse)
+        assert response.total_notifications_sent == 1
+        mock_send_mail.assert_called_once()
+        assert "email" in self.notification_manager.get_supported_channels()
+
 
 class TestNotificationRecipientResolver(NotificationsBaseTestCase):
     def test_default_resolution_strategy(self):