solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/component.py

@@ -2,9 +2,9 @@
 Custom Solace AI Connector Component to host the FastAPI backend for the Web UI.
 """
 
-import logging
 import asyncio
 import json
+import logging
 import queue
 import re
 import threading
@@ -15,22 +15,20 @@ from typing import Any
 import uvicorn
 from fastapi import FastAPI, UploadFile
 from fastapi import Request as FastAPIRequest
-
+from solace_ai_connector.common.event import Event, EventType
 from solace_ai_connector.components.inputs_outputs.broker_input import BrokerInput
 from solace_ai_connector.flow.app import App as SACApp
-from solace_ai_connector.common.event import Event, EventType
 
 from ...common.agent_registry import AgentRegistry
 from ...core_a2a.service import CoreA2AService
 from ...gateway.base.component import BaseGatewayComponent
 from ...gateway.http_sse.session_manager import SessionManager
 from ...gateway.http_sse.sse_manager import SSEManager
-from .sse_event_buffer import SSEEventBuffer
+from . import dependencies
 from .components import VisualizationForwarderComponent
 from .components.task_logger_forwarder import TaskLoggerForwarderComponent
-from .services.feedback_service import FeedbackService
 from .services.task_logger_service import TaskLoggerService
-from . import dependencies
+from .sse_event_buffer import SSEEventBuffer
 
 log = logging.getLogger(__name__)
 
@@ -97,7 +95,16 @@ class WebUIBackendComponent(BaseGatewayComponent):
         app_config = component_config.get("app_config", {})
         resolve_uris = app_config.get("resolve_artifact_uris_in_gateway", True)
 
-        super().__init__(resolve_artifact_uris_in_gateway=resolve_uris, **kwargs)
+        # HTTP SSE gateway configuration:
+        # - supports_inline_artifact_resolution=True: Artifacts are converted to FileParts
+        #   during embed resolution and rendered inline in the web UI
+        # - filter_tool_data_parts=False: Web UI displays all parts including tool execution details
+        super().__init__(
+            resolve_artifact_uris_in_gateway=resolve_uris,
+            supports_inline_artifact_resolution=True,
+            filter_tool_data_parts=False,
+            **kwargs
+        )
         log.info("%s Initializing Web UI Backend Component...", self.log_identifier)
 
         try:
@@ -115,6 +122,14 @@ class WebUIBackendComponent(BaseGatewayComponent):
             self.ssl_keyfile = self.get_config("ssl_keyfile", "")
             self.ssl_certfile = self.get_config("ssl_certfile", "")
             self.ssl_keyfile_password = self.get_config("ssl_keyfile_password", "")
+            self.model_config = self.get_config("model", None)
+
+            # OAuth2 configuration (enterprise feature - defaults to community mode)
+            self.external_auth_service_url = self.get_config("external_auth_service_url", "")
+            self.external_auth_provider = self.get_config("external_auth_provider", "generic")
+
+            # frontend_server_url is optional - empty string means frontend uses relative URLs
+            self.frontend_server_url = self.get_config("frontend_server_url", "")
 
             log.info(
                 "%s WebUI-specific configuration retrieved (Host: %s, Port: %d).",
@@ -126,16 +141,15 @@ class WebUIBackendComponent(BaseGatewayComponent):
             log.error("%s Failed to retrieve configuration: %s", self.log_identifier, e)
             raise ValueError(f"Configuration retrieval error: {e}") from e
 
-        sse_max_queue_size = self.get_config("sse_max_queue_size", 200)
+        self.sse_max_queue_size = self.get_config("sse_max_queue_size", 200)
         sse_buffer_max_age_seconds = self.get_config("sse_buffer_max_age_seconds", 600)
 
         self.sse_event_buffer = SSEEventBuffer(
-            max_queue_size=sse_max_queue_size,
+            max_queue_size=self.sse_max_queue_size,
             max_age_seconds=sse_buffer_max_age_seconds,
         )
-        self.sse_manager = SSEManager(
-            max_queue_size=sse_max_queue_size, event_buffer=self.sse_event_buffer
-        )
+        # SSE manager will be initialized after database setup
+        self.sse_manager = None
 
         self._sse_cleanup_timer_id = f"sse_cleanup_{self.gateway_id}"
         cleanup_interval_sec = self.get_config(
@@ -146,11 +160,14 @@ class WebUIBackendComponent(BaseGatewayComponent):
             timer_id=self._sse_cleanup_timer_id,
             interval_ms=cleanup_interval_sec * 1000,
         )
-        
+
         # Set up health check timer for agent registry
         from ...common.constants import HEALTH_CHECK_INTERVAL_SECONDS
+
         self.health_check_timer_id = f"agent_health_check_{self.gateway_id}"
-        health_check_interval_seconds = self.get_config("agent_health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS)
+        health_check_interval_seconds = self.get_config(
+            "agent_health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS
+        )
         if health_check_interval_seconds > 0:
             log.info(
                 "%s Scheduling agent health check every %d seconds.",
@@ -181,8 +198,9 @@ class WebUIBackendComponent(BaseGatewayComponent):
         else:
             # Memory storage or no explicit configuration - no persistence service needed
             self.database_url = None
-            
-            # Validate that features requiring database persistence are not enabled
+
+        # Validate that features requiring runtime database persistence are not enabled without database
+        if self.database_url is None:
             task_logging_config = self.get_config("task_logging", {})
             if task_logging_config.get("enabled", False):
                 raise ValueError(
@@ -190,15 +208,17 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     "Either set session_service.type='sql' with a valid database_url, "
                     "or disable task_logging.enabled."
                 )
-            
+
             feedback_config = self.get_config("feedback_publishing", {})
             if feedback_config.get("enabled", False):
                 log.warning(
                     "%s Feedback publishing is enabled but database persistence is not configured. "
                     "Feedback will only be published to the broker, not stored locally.",
-                    self.log_identifier
+                    self.log_identifier,
                 )
 
+        platform_config = self.get_config("platform_service", {})
+        self.platform_service_url = platform_config.get("url", "")
         component_config = self.get_config("component_config", {})
         app_config = component_config.get("app_config", {})
 
@@ -226,6 +246,10 @@ class WebUIBackendComponent(BaseGatewayComponent):
         self._task_logger_broker_input: BrokerInput | None = None
         self._task_logger_processor_task: asyncio.Task | None = None
         self.task_logger_service: TaskLoggerService | None = None
+        
+        # Background task monitor
+        self.background_task_monitor = None
+        self._background_task_monitor_timer_id = None
 
         # Initialize SAM Events service for system events
         from ...common.sam_events import SamEventService
@@ -241,27 +265,33 @@ class WebUIBackendComponent(BaseGatewayComponent):
         self._data_retention_timer_id = None
         data_retention_config = self.get_config("data_retention", {})
         if data_retention_config.get("enabled", True):
-            log.info("%s Data retention is enabled. Initializing service and timer...", self.log_identifier)
-            
+            log.info(
+                "%s Data retention is enabled. Initializing service and timer...",
+                self.log_identifier,
+            )
+
             # Import and initialize the DataRetentionService
             from .services.data_retention_service import DataRetentionService
-            
+
             session_factory = None
             if self.database_url:
                 # SessionLocal will be initialized later in setup_dependencies
                 # We'll pass a lambda that returns SessionLocal when called
-                session_factory = lambda: dependencies.SessionLocal() if dependencies.SessionLocal else None
-            
+                session_factory = lambda: (
+                    dependencies.SessionLocal() if dependencies.SessionLocal else None
+                )
+
             self.data_retention_service = DataRetentionService(
-                session_factory=session_factory,
-                config=data_retention_config
+                session_factory=session_factory, config=data_retention_config
             )
-            
+
             # Create and start the cleanup timer
-            cleanup_interval_hours = data_retention_config.get("cleanup_interval_hours", 24)
+            cleanup_interval_hours = data_retention_config.get(
+                "cleanup_interval_hours", 24
+            )
             cleanup_interval_ms = cleanup_interval_hours * 60 * 60 * 1000
             self._data_retention_timer_id = f"data_retention_cleanup_{self.gateway_id}"
-            
+
             self.add_timer(
                 delay_ms=cleanup_interval_ms,
                 timer_id=self._data_retention_timer_id,
@@ -274,14 +304,35 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 cleanup_interval_hours,
             )
         else:
-            log.info("%s Data retention is disabled via configuration.", self.log_identifier)
+            log.info(
+                "%s Data retention is disabled via configuration.", self.log_identifier
+            )
+
+        if self.database_url:
+            log.info("%s Running database migrations...", self.log_identifier)
+            self._run_database_migrations()
+            log.info("%s Database migrations completed", self.log_identifier)
 
         log.info("%s Web UI Backend Component initialized.", self.log_identifier)
 
+    def _run_database_migrations(self):
+        """Run database migrations synchronously during __init__."""
+        try:
+            from ...gateway.http_sse.main import _setup_database
+            _setup_database(self.database_url)
+        except Exception as e:
+            log.error(
+                "%s Failed to run database migrations: %s",
+                self.log_identifier,
+                e,
+                exc_info=True
+            )
+            raise RuntimeError(f"Database migration failed during component initialization: {e}") from e
+
     def process_event(self, event: Event):
         if event.event_type == EventType.TIMER:
             timer_id = event.data.get("timer_id")
-            
+
             if timer_id == self._sse_cleanup_timer_id:
                 log.debug("%s SSE buffer cleanup timer triggered.", self.log_identifier)
                 self.sse_event_buffer.cleanup_stale_buffers()
@@ -290,9 +341,11 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 log.debug("%s Agent health check timer triggered.", self.log_identifier)
                 self._check_agent_health()
                 return
-            
+
             if timer_id == self._data_retention_timer_id:
-                log.debug("%s Data retention cleanup timer triggered.", self.log_identifier)
+                log.debug(
+                    "%s Data retention cleanup timer triggered.", self.log_identifier
+                )
                 if self.data_retention_service:
                     try:
                         self.data_retention_service.cleanup_old_data()
@@ -309,6 +362,27 @@ class WebUIBackendComponent(BaseGatewayComponent):
                         self.log_identifier,
                     )
                 return
+            
+            if timer_id == self._background_task_monitor_timer_id:
+                log.debug("%s Background task monitor timer triggered.", self.log_identifier)
+                if self.background_task_monitor:
+                    loop = self.get_async_loop()
+                    if loop and loop.is_running():
+                        asyncio.run_coroutine_threadsafe(
+                            self.background_task_monitor.check_timeouts(),
+                            loop
+                        )
+                    else:
+                        log.warning(
+                            "%s Async loop not available for background task monitor.",
+                            self.log_identifier
+                        )
+                else:
+                    log.warning(
+                        "%s Background task monitor timer fired but service is not initialized.",
+                        self.log_identifier,
+                    )
+                return
 
         super().process_event(event)
 
@@ -364,7 +438,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             broker_input_cfg = {
                 "component_module": "broker_input",
                 "component_name": f"{self.gateway_id}_viz_broker_input",
-                "broker_queue_name": f"{self.namespace.strip('/')}/q/gdk/viz/{self.gateway_id}/{uuid.uuid4().hex}",
+                "broker_queue_name": f"{self.namespace.strip('/')}/q/gdk/viz/{self.gateway_id}",
                 "create_queue_on_start": True,
                 "component_config": {
                     "broker_url": main_broker_config.get("broker_url"),
@@ -386,7 +460,9 @@ class WebUIBackendComponent(BaseGatewayComponent):
             forwarder_cfg = {
                 "component_class": VisualizationForwarderComponent,
                 "component_name": f"{self.gateway_id}_viz_forwarder",
-                "component_config": {"target_queue_ref": self._visualization_message_queue},
+                "component_config": {
+                    "target_queue_ref": self._visualization_message_queue
+                },
             }
 
             flow_config = {
@@ -437,7 +513,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     raise RuntimeError(
                         "Visualization flow setup error: BrokerInput not found."
                     )
-                log.info(
+                log.debug(
                     "%s Obtained reference to internal BrokerInput component.",
                     log_id_prefix,
                 )
@@ -496,7 +572,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             broker_input_cfg = {
                 "component_module": "broker_input",
                 "component_name": f"{self.gateway_id}_task_log_broker_input",
-                "broker_queue_name": f"{self.namespace.strip('/')}/q/gdk/task_log/{self.gateway_id}/{uuid.uuid4().hex}",
+                "broker_queue_name": f"{self.namespace.strip('/')}/q/gdk/task_log/{self.gateway_id}",
                 "create_queue_on_start": True,
                 "component_config": {
                     "broker_url": main_broker_config.get("broker_url"),
@@ -786,11 +862,34 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                     event_details["direction"],
                                 )
                             except asyncio.QueueFull:
-                                log.warning(
-                                    "%s SSE queue full for stream %s. Visualization message dropped.",
-                                    log_id_prefix,
-                                    stream_id,
-                                )
+                                # Check if this is a background task
+                                is_background = False
+                                if task_id_for_context and self.database_url:
+                                    try:
+                                        from .repository.task_repository import TaskRepository
+                                        db = dependencies.SessionLocal()
+                                        try:
+                                            repo = TaskRepository()
+                                            task = repo.find_by_id(db, task_id_for_context)
+                                            is_background = task and task.background_execution_enabled
+                                        finally:
+                                            db.close()
+                                    except Exception:
+                                        pass
+                                
+                                if is_background:
+                                    log.debug(
+                                        "%s SSE queue full for stream %s. Dropping visualization message for background task %s.",
+                                        log_id_prefix,
+                                        stream_id,
+                                        task_id_for_context,
+                                    )
+                                else:
+                                    log.warning(
+                                        "%s SSE queue full for stream %s. Visualization message dropped.",
+                                        log_id_prefix,
+                                        stream_id,
+                                    )
                             except Exception as send_err:
                                 log.error(
                                     "%s Error sending formatted message to SSE queue for stream %s: %s",
@@ -883,7 +982,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
         Manages global subscription reference counts.
         """
         log_id_prefix = f"{self.log_identifier}[AddVizSub:{stream_id}]"
-        log.info(
+        log.debug(
             "%s Attempting to add subscription to topic: %s", log_id_prefix, topic_str
         )
 
@@ -1164,7 +1263,12 @@ class WebUIBackendComponent(BaseGatewayComponent):
                         log_id_prefix,
                         username,
                     )
-                    return {"id": username, "name": username, "email": username, "user_info": user_info}
+                    return {
+                        "id": username,
+                        "name": username,
+                        "email": username,
+                        "user_info": user_info,
+                    }
 
             log.debug(
                 "%s No authenticated user in request.state, falling back to SessionManager.",
@@ -1198,19 +1302,79 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
             self.fastapi_app = fastapi_app_instance
 
-            setup_dependencies(self, self.database_url)
+            setup_dependencies(self)
 
             # Instantiate services that depend on the database session factory.
             # This must be done *after* setup_dependencies has run.
             session_factory = dependencies.SessionLocal if self.database_url else None
+            
+            # Initialize SSE manager with session factory for background task detection
+            self.sse_manager = SSEManager(
+                max_queue_size=self.sse_max_queue_size,
+                event_buffer=self.sse_event_buffer,
+                session_factory=session_factory
+            )
+            log.debug(
+                "%s SSE manager initialized with database session factory.",
+                self.log_identifier,
+            )
             task_logging_config = self.get_config("task_logging", {})
             self.task_logger_service = TaskLoggerService(
                 session_factory=session_factory, config=task_logging_config
             )
-            log.info(
+            log.debug(
                 "%s Services dependent on database session factory have been initialized.",
                 self.log_identifier,
             )
+            
+            # Initialize background task monitor if task logging is enabled
+            if self.database_url and task_logging_config.get("enabled", False):
+                from .services.background_task_monitor import BackgroundTaskMonitor
+                from .services.task_service import TaskService
+                
+                # Create task service for cancellation operations
+                task_service = TaskService(
+                    core_a2a_service=self.core_a2a_service,
+                    publish_func=self.publish_a2a,
+                    namespace=self.namespace,
+                    gateway_id=self.gateway_id,
+                    sse_manager=self.sse_manager,
+                    task_context_map=self.task_context_manager._contexts,
+                    task_context_lock=self.task_context_manager._lock,
+                    app_name=self.name,
+                )
+                
+                # Get timeout configuration
+                background_config = self.get_config("background_tasks", {})
+                default_timeout_ms = background_config.get("default_timeout_ms", 3600000)  # 1 hour
+                
+                self.background_task_monitor = BackgroundTaskMonitor(
+                    session_factory=session_factory,
+                    task_service=task_service,
+                    default_timeout_ms=default_timeout_ms,
+                )
+                
+                # Create timer for periodic timeout checks
+                monitor_interval_ms = background_config.get("monitor_interval_ms", 300000)  # 5 minutes
+                self._background_task_monitor_timer_id = f"background_task_monitor_{self.gateway_id}"
+                
+                self.add_timer(
+                    delay_ms=monitor_interval_ms,
+                    timer_id=self._background_task_monitor_timer_id,
+                    interval_ms=monitor_interval_ms,
+                )
+                
+                log.info(
+                    "%s Background task monitor initialized with %dms check interval and %dms default timeout",
+                    self.log_identifier,
+                    monitor_interval_ms,
+                    default_timeout_ms
+                )
+            else:
+                log.info(
+                    "%s Background task monitor not initialized (task logging disabled or no database)",
+                    self.log_identifier
+                )
 
             port = (
                 self.fastapi_https_port
@@ -1227,6 +1391,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 ssl_keyfile=self.ssl_keyfile,
                 ssl_certfile=self.ssl_certfile,
                 ssl_keyfile_password=self.ssl_keyfile_password,
+                log_config=None
             )
             self.uvicorn_server = uvicorn.Server(config)
 
@@ -1238,14 +1403,14 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 )
                 try:
                     self.fastapi_event_loop = asyncio.get_running_loop()
-                    log.info(
+                    log.debug(
                         "%s [_start_listener] Captured FastAPI event loop via startup event: %s",
                         self.log_identifier,
                         self.fastapi_event_loop,
                     )
 
                     if self.fastapi_event_loop:
-                        log.info(
+                        log.debug(
                             "%s Ensuring visualization flow is running...",
                             self.log_identifier,
                         )
@@ -1255,7 +1420,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                             self._visualization_processor_task is None
                             or self._visualization_processor_task.done()
                         ):
-                            log.info(
+                            log.debug(
                                 "%s Starting visualization message processor task.",
                                 self.log_identifier,
                             )
@@ -1265,7 +1430,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                 )
                             )
                         else:
-                            log.info(
+                            log.debug(
                                 "%s Visualization message processor task already running.",
                                 self.log_identifier,
                             )
@@ -1297,7 +1462,9 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                     self.log_identifier,
                                 )
                         else:
-                            log.info("%s Task logging is disabled.", self.log_identifier)
+                            log.info(
+                                "%s Task logging is disabled.", self.log_identifier
+                            )
                     else:
                         log.error(
                             "%s FastAPI event loop not captured. Cannot start visualization processor.",
@@ -1312,27 +1479,6 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     )
                     self.stop_signal.set()
 
-                try:
-                    from solace_agent_mesh_enterprise.init_enterprise import start_enterprise_background_tasks
-                    log.info("%s Starting enterprise background tasks...", self.log_identifier)
-                    await start_enterprise_background_tasks(self)
-                    log.info("%s Enterprise background tasks started successfully", self.log_identifier)
-                except ImportError:
-                    log.debug("%s Enterprise package not available - skipping background tasks", self.log_identifier)
-                except RuntimeError as enterprise_err:
-                    log.warning(
-                        "%s Enterprise background tasks disabled: %s - Community features will continue normally",
-                        self.log_identifier,
-                        enterprise_err
-                    )
-                except Exception as enterprise_err:
-                    log.error(
-                        "%s Failed to start enterprise background tasks: %s - Community features will continue normally",
-                        self.log_identifier,
-                        enterprise_err,
-                        exc_info=True
-                    )
-
             @self.fastapi_app.on_event("shutdown")
             async def shutdown_event():
                 log.info(
@@ -1340,21 +1486,6 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     self.log_identifier,
                 )
 
-                try:
-                    from solace_agent_mesh_enterprise.init_enterprise import stop_enterprise_background_tasks
-                    log.info("%s Stopping enterprise background tasks...", self.log_identifier)
-                    await stop_enterprise_background_tasks()
-                    log.info("%s Enterprise background tasks stopped", self.log_identifier)
-                except ImportError:
-                    log.debug("%s Enterprise package not available - no background tasks to stop", self.log_identifier)
-                except Exception as enterprise_err:
-                    log.error(
-                        "%s Failed to stop enterprise background tasks: %s",
-                        self.log_identifier,
-                        enterprise_err,
-                        exc_info=True
-                    )
-
             self.fastapi_thread = threading.Thread(
                 target=self.uvicorn_server.run, daemon=True, name="FastAPI_Thread"
             )
@@ -1417,18 +1548,27 @@ class WebUIBackendComponent(BaseGatewayComponent):
     def cleanup(self):
         """Gracefully shuts down the component and the FastAPI server."""
         log.info("%s Cleaning up Web UI Backend Component...", self.log_identifier)
-        
+
         # Cancel timers
         self.cancel_timer(self._sse_cleanup_timer_id)
         if self._data_retention_timer_id:
             self.cancel_timer(self._data_retention_timer_id)
             log.info("%s Cancelled data retention cleanup timer.", self.log_identifier)
         
+        if self._background_task_monitor_timer_id:
+            self.cancel_timer(self._background_task_monitor_timer_id)
+            log.info("%s Cancelled background task monitor timer.", self.log_identifier)
+
         # Clean up data retention service
         if self.data_retention_service:
             self.data_retention_service = None
             log.info("%s Data retention service cleaned up.", self.log_identifier)
         
+        # Clean up background task monitor
+        if self.background_task_monitor:
+            self.background_task_monitor = None
+            log.info("%s Background task monitor cleaned up.", self.log_identifier)
+
         self.cancel_timer(self.health_check_timer_id)
         log.info("%s Cleaning up visualization resources...", self.log_identifier)
         if self._visualization_message_queue:
@@ -1445,7 +1585,10 @@ class WebUIBackendComponent(BaseGatewayComponent):
             )
             self._visualization_processor_task.cancel()
 
-        if self._task_logger_processor_task and not self._task_logger_processor_task.done():
+        if (
+            self._task_logger_processor_task
+            and not self._task_logger_processor_task.done()
+        ):
             log.info("%s Cancelling task logger processor task...", self.log_identifier)
             self._task_logger_processor_task.cancel()
 
@@ -1755,70 +1898,88 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
     def get_agent_registry(self) -> AgentRegistry:
         return self.agent_registry
-        
+
     def _check_agent_health(self):
         """
         Checks the health of peer agents and de-registers unresponsive ones.
         This is called periodically by the health check timer.
         Uses TTL-based expiration to determine if an agent is unresponsive.
         """
-            
+
         log.debug("%s Performing agent health check...", self.log_identifier)
-        
+
         # Get TTL from configuration or use default from constants
-        from ...common.constants import HEALTH_CHECK_TTL_SECONDS, HEALTH_CHECK_INTERVAL_SECONDS
-        ttl_seconds = self.get_config("agent_health_check_ttl_seconds", HEALTH_CHECK_TTL_SECONDS)
-        health_check_interval = self.get_config("agent_health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS)
+        from ...common.constants import (
+            HEALTH_CHECK_INTERVAL_SECONDS,
+            HEALTH_CHECK_TTL_SECONDS,
+        )
+
+        ttl_seconds = self.get_config(
+            "agent_health_check_ttl_seconds", HEALTH_CHECK_TTL_SECONDS
+        )
+        health_check_interval = self.get_config(
+            "agent_health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS
+        )
 
         log.debug(
             "%s Health check configuration: interval=%d seconds, TTL=%d seconds",
             self.log_identifier,
             health_check_interval,
-            ttl_seconds
+            ttl_seconds,
         )
-        
+
         # Validate configuration values
-        if ttl_seconds <= 0 or health_check_interval <= 0 or ttl_seconds < health_check_interval:
+        if (
+            ttl_seconds <= 0
+            or health_check_interval <= 0
+            or ttl_seconds < health_check_interval
+        ):
             log.error(
                 "%s agent_health_check_ttl_seconds (%d) and agent_health_check_interval_seconds (%d) must be positive and TTL must be greater than interval.",
                 self.log_identifier,
                 ttl_seconds,
-                health_check_interval
+                health_check_interval,
             )
-            raise ValueError(f"Invalid health check configuration. agent_health_check_ttl_seconds ({ttl_seconds}) and agent_health_check_interval_seconds ({health_check_interval}) must be positive and TTL must be greater than interval.")
-        
+            raise ValueError(
+                f"Invalid health check configuration. agent_health_check_ttl_seconds ({ttl_seconds}) and agent_health_check_interval_seconds ({health_check_interval}) must be positive and TTL must be greater than interval."
+            )
+
         # Get all agent names from the registry
         agent_names = self.agent_registry.get_agent_names()
         total_agents = len(agent_names)
         agents_to_deregister = []
-        
-        log.debug("%s Checking health of %d peer agents", self.log_identifier, total_agents)
-        
+
+        log.debug(
+            "%s Checking health of %d peer agents", self.log_identifier, total_agents
+        )
+
         for agent_name in agent_names:
             # Check if the agent's TTL has expired
-            is_expired, time_since_last_seen = self.agent_registry.check_ttl_expired(agent_name, ttl_seconds)
-            
+            is_expired, time_since_last_seen = self.agent_registry.check_ttl_expired(
+                agent_name, ttl_seconds
+            )
+
             if is_expired:
                 log.warning(
                     "%s Agent '%s' TTL has expired. De-registering. Time since last seen: %d seconds (TTL: %d seconds)",
                     self.log_identifier,
                     agent_name,
                     time_since_last_seen,
-                    ttl_seconds
+                    ttl_seconds,
                 )
                 agents_to_deregister.append(agent_name)
-        
+
         # De-register unresponsive agents
         for agent_name in agents_to_deregister:
             self._deregister_agent(agent_name)
-            
-        log.info(
+
+        log.debug(
             "%s Agent health check completed. Total agents: %d, De-registered: %d",
             self.log_identifier,
             total_agents,
-            len(agents_to_deregister)
+            len(agents_to_deregister),
         )
-        
+
     def _deregister_agent(self, agent_name: str):
         """
         De-registers an agent from the registry and publishes a de-registration event.
@@ -1865,52 +2026,6 @@ class WebUIBackendComponent(BaseGatewayComponent):
         """Returns the instance of the ConfigResolver."""
         return self._config_resolver
 
-    async def _resolve_embeds_for_persistence(
-        self, message_content: str, session_id: str, user_id: str, log_identifier: str
-    ) -> str:
-        """
-        Resolves embeds in a message for database storage.
-        Returns the resolved text.
-
-        Args:
-            message_content: The message text that may contain embeds
-            session_id: The A2A session ID
-            user_id: The user ID
-            log_identifier: Logging identifier
-
-        Returns:
-            The message with embeds resolved (or original if resolution fails)
-        """
-        try:
-            embed_context = {
-                "artifact_service": self.shared_artifact_service,
-                "session_context": {
-                    "app_name": self.gateway_id,
-                    "user_id": user_id,
-                    "session_id": session_id,
-                },
-                "config": self.get_embed_config(),
-            }
-
-            resolved_text, _, _ = await resolve_embeds_in_string(
-                text=message_content,
-                context=embed_context,
-                resolver_func=evaluate_embed,
-                types_to_resolve=EARLY_EMBED_TYPES,
-                log_identifier=log_identifier,
-                config=embed_context["config"],
-            )
-
-            return resolved_text
-
-        except Exception as e:
-            log.warning(
-                "%s Error resolving embeds for storage: %s. Using original message.",
-                log_identifier,
-                e,
-            )
-            return message_content
-
     def _start_listener(self) -> None:
         """
         GDK Hook: Starts the FastAPI/Uvicorn server.
@@ -2052,6 +2167,15 @@ class WebUIBackendComponent(BaseGatewayComponent):
             )
             return
 
+        try:
+            from solace_agent_mesh_enterprise.auth.input_required import (
+                handle_input_required_request,
+            )
+
+            event_data = handle_input_required_request(event_data, sse_task_id, self)
+        except ImportError:
+            pass
+
         log.debug(
             "%s Sending update for A2A Task ID %s to SSE Task ID %s. Final chunk: %s",
             log_id_prefix,
@@ -2073,7 +2197,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             await self.sse_manager.send_event(
                 task_id=sse_task_id, event_data=sse_payload, event_type=sse_event_type
             )
-            log.info(
+            log.debug(
                 "%s Successfully sent %s via SSE for A2A Task ID %s.",
                 log_id_prefix,
                 sse_event_type,
@@ -2111,7 +2235,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             )
             return
 
-        log.debug(
+        log.info(
             "%s Sending final response for A2A Task ID %s to SSE Task ID %s.",
             log_id_prefix,
             a2a_task_id,
@@ -2127,7 +2251,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             await self.sse_manager.send_event(
                 task_id=sse_task_id, event_data=sse_payload, event_type="final_response"
             )
-            log.info(
+            log.debug(
                 "%s Successfully sent final_response via SSE for A2A Task ID %s.",
                 log_id_prefix,
                 a2a_task_id,
@@ -2147,6 +2271,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 log_id_prefix,
                 sse_task_id,
             )
+            
 
     async def _send_error_to_external(
         self, external_request_context: dict[str, Any], error_data: JSONRPCError