solace-agent-mesh 1.6.1__py3-none-any.whl → 1.6.3__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__)
 
@@ -115,6 +113,7 @@ 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)
 
             log.info(
                 "%s WebUI-specific configuration retrieved (Host: %s, Port: %d).",
@@ -146,11 +145,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 +183,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 +193,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_database_url = platform_config.get("database_url")
         component_config = self.get_config("component_config", {})
         app_config = component_config.get("app_config", {})
 
@@ -241,27 +246,35 @@ 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 +287,16 @@ 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
+            )
 
         log.info("%s Web UI Backend Component initialized.", self.log_identifier)
 
     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 +305,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()
@@ -386,7 +403,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 +456,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,
                 )
@@ -883,7 +902,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 +1183,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,7 +1222,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
             self.fastapi_app = fastapi_app_instance
 
-            setup_dependencies(self, self.database_url)
+            setup_dependencies(self, self.database_url, self.platform_database_url)
 
             # Instantiate services that depend on the database session factory.
             # This must be done *after* setup_dependencies has run.
@@ -1207,7 +1231,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             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,
             )
@@ -1238,14 +1262,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 +1279,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 +1289,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                 )
                             )
                         else:
-                            log.info(
+                            log.debug(
                                 "%s Visualization message processor task already running.",
                                 self.log_identifier,
                             )
@@ -1297,7 +1321,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.",
@@ -1313,24 +1339,36 @@ 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)
+                    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)
+                    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)
+                    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
+                        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
+                        exc_info=True,
                     )
 
             @self.fastapi_app.on_event("shutdown")
@@ -1341,18 +1379,29 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 )
 
                 try:
-                    from solace_agent_mesh_enterprise.init_enterprise import stop_enterprise_background_tasks
-                    log.info("%s Stopping enterprise background tasks...", self.log_identifier)
+                    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)
+                    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)
+                    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
+                        exc_info=True,
                     )
 
             self.fastapi_thread = threading.Thread(
@@ -1417,18 +1466,18 @@ 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)
-        
+
         # 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)
-        
+
         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 +1494,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()
 
@@ -1659,9 +1711,9 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 (summary_str[:100] + "...") if len(summary_str) > 100 else summary_str
             )
         except Exception:
-            details["payload_summary"][
-                "params_preview"
-            ] = "[Could not serialize payload]"
+            details["payload_summary"]["params_preview"] = (
+                "[Could not serialize payload]"
+            )
 
         return details
 
@@ -1755,70 +1807,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.
@@ -2052,6 +2122,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 +2152,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,