solace-agent-mesh 1.4.11__py3-none-any.whl → 1.5.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/components/task_logger_forwarder.py

@@ -0,0 +1,108 @@
+"""
+SAC Component to forward messages from an internal BrokerInput
+to the WebUIBackendComponent's internal queue for task logging.
+"""
+
+import queue
+from typing import Any, Dict
+
+from solace_ai_connector.components.component_base import ComponentBase
+from solace_ai_connector.common.message import Message as SolaceMessage
+from solace_ai_connector.common.log import log
+
+info = {
+    "class_name": "TaskLoggerForwarderComponent",
+    "description": (
+        "Forwards A2A messages from an internal BrokerInput to the main "
+        "WebUIBackendComponent's internal queue for task logging."
+    ),
+    "config_parameters": [
+        {
+            "name": "target_queue_ref",
+            "required": True,
+            "type": "queue.Queue",
+            "description": "A direct reference to the target queue.Queue instance in WebUIBackendComponent.",
+        }
+    ],
+    "input_schema": {
+        "type": "object",
+        "description": "Output from a BrokerInput component.",
+        "properties": {
+            "payload": {"type": "any", "description": "The message payload."},
+            "topic": {"type": "string", "description": "The message topic."},
+            "user_properties": {
+                "type": "object",
+                "description": "User properties of the message.",
+            },
+        },
+        "required": ["payload", "topic"],
+    },
+    "output_schema": None,
+}
+
+
+class TaskLoggerForwarderComponent(ComponentBase):
+    """
+    A simple SAC component that takes messages from its input (typically
+    from a BrokerInput) and puts them onto a target Python queue.Queue
+    instance provided in its configuration.
+    """
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(info, **kwargs)
+        self.target_queue: queue.Queue = self.get_config("target_queue_ref")
+        if not isinstance(self.target_queue, queue.Queue):
+            log.error(
+                "%s Configuration 'target_queue_ref' is not a valid queue.Queue instance. Type: %s",
+                self.log_identifier,
+                type(self.target_queue),
+            )
+            raise ValueError(
+                f"{self.log_identifier} 'target_queue_ref' must be a queue.Queue instance."
+            )
+        log.info("%s TaskLoggerForwarderComponent initialized.", self.log_identifier)
+
+    def invoke(self, message: SolaceMessage, data: Dict[str, Any]) -> None:
+        """
+        Processes the incoming message and forwards it.
+
+        Args:
+            message: The SolaceMessage object from BrokerInput (this is the original message).
+            data: The data extracted by BrokerInput's output_schema (payload, topic, user_properties).
+        """
+        log_id_prefix = f"{self.log_identifier}[Invoke]"
+        try:
+
+            forward_data = {
+                "topic": data.get("topic"),
+                "payload": data.get("payload"),
+                "user_properties": data.get("user_properties") or {},
+                "_original_broker_message": message,
+            }
+            log.debug(
+                "%s Forwarding message for topic: %s",
+                log_id_prefix,
+                forward_data["topic"],
+            )
+            try:
+                self.target_queue.put_nowait(forward_data)
+            except queue.Full:
+                log.warning(
+                    "%s Task logging queue is full. Message dropped. Current size: %d",
+                    log_id_prefix,
+                    self.target_queue.qsize(),
+                )
+
+            message.call_acknowledgements()
+            log.debug("%s Message acknowledged to BrokerInput.", log_id_prefix)
+
+        except Exception as e:
+            log.exception(
+                "%s Error in TaskLoggerForwarderComponent invoke: %s",
+                log_id_prefix,
+                e,
+            )
+            if message:
+                message.call_negative_acknowledgements()
+            raise
+        return None

solace_agent_mesh/gateway/http_sse/components/visualization_forwarder_component.py

@@ -76,7 +76,7 @@ class VisualizationForwarderComponent(ComponentBase):
             forward_data = {
                 "topic": data.get("topic"),
                 "payload": data.get("payload"),
-                "user_properties": data.get("user_properties"),
+                "user_properties": data.get("user_properties") or {},
                 "_original_broker_message": message,
             }
             log.debug(

solace_agent_mesh/gateway/http_sse/dependencies.py

@@ -20,9 +20,14 @@ from ...gateway.base.task_context import TaskContextManager
 from ...gateway.http_sse.services.agent_card_service import AgentCardService
 from ...gateway.http_sse.services.people_service import PeopleService
 from ...gateway.http_sse.services.task_service import TaskService
+from ...gateway.http_sse.services.feedback_service import FeedbackService
+from ...gateway.http_sse.services.task_logger_service import TaskLoggerService
+from ...gateway.http_sse.services.data_retention_service import DataRetentionService
 from ...gateway.http_sse.session_manager import SessionManager
 from ...gateway.http_sse.sse_manager import SSEManager
-from .repository import Message, MessageRepository, SessionRepository
+from .repository import SessionRepository
+from .repository.interfaces import ITaskRepository
+from .repository.task_repository import TaskRepository
 from .services.session_service import SessionService
 
 try:
@@ -57,8 +62,20 @@ def init_database(database_url: str):
     global SessionLocal
     if SessionLocal is None:
         engine = create_engine(database_url)
+
+        # Enable foreign keys for SQLite only (database-agnostic)
+        from sqlalchemy import event
+
+        @event.listens_for(engine, "connect")
+        def set_sqlite_pragma(dbapi_conn, connection_record):
+            # Only apply to SQLite connections
+            if database_url.startswith("sqlite"):
+                cursor = dbapi_conn.cursor()
+                cursor.execute("PRAGMA foreign_keys=ON")
+                cursor.close()
+
         SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-        log.info("[Dependencies] Database initialized.")
+        log.info("[Dependencies] Database initialized with foreign key support.")
     else:
         log.warning("[Dependencies] Database already initialized.")
 
@@ -199,6 +216,23 @@ def get_identity_service(
     return component.identity_service
 
 
+def get_db() -> Generator[Session, None, None]:
+    if SessionLocal is None:
+        raise HTTPException(
+            status_code=status.HTTP_501_NOT_IMPLEMENTED,
+            detail="Session management requires database configuration.",
+        )
+    db = SessionLocal()
+    try:
+        yield db
+        db.commit()
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()
+
+
 def get_people_service(
     identity_service: BaseIdentityService | None = Depends(get_identity_service),
 ) -> PeopleService:
@@ -207,6 +241,73 @@ def get_people_service(
     return PeopleService(identity_service=identity_service)
 
 
+def get_task_repository(db: Session = Depends(get_db)) -> ITaskRepository:
+    """FastAPI dependency to get an instance of TaskRepository."""
+    log.debug("[Dependencies] get_task_repository called")
+    return TaskRepository(db)
+
+
+def get_feedback_service(
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+    task_repo: ITaskRepository = Depends(get_task_repository),
+) -> FeedbackService:
+    """FastAPI dependency to get an instance of FeedbackService."""
+    log.debug("[Dependencies] get_feedback_service called")
+    # The session factory is needed for the existing DB save logic.
+    session_factory = SessionLocal if component.database_url else None
+    return FeedbackService(
+        session_factory=session_factory, component=component, task_repo=task_repo
+    )
+
+
+def get_data_retention_service(
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+) -> "DataRetentionService | None":
+    """
+    FastAPI dependency to get the DataRetentionService instance.
+
+    Returns:
+        DataRetentionService instance if database is configured and service is initialized,
+        None otherwise.
+
+    Note:
+        This dependency is primarily for future API endpoints that might expose
+        data retention statistics or manual cleanup triggers. The service itself
+        runs automatically via timer in the component.
+    """
+    log.debug("[Dependencies] get_data_retention_service called")
+
+    if not component.database_url:
+        log.debug(
+            "[Dependencies] Database not configured, returning None for data retention service"
+        )
+        return None
+
+    if (
+        not hasattr(component, "data_retention_service")
+        or component.data_retention_service is None
+    ):
+        log.warning("[Dependencies] DataRetentionService not initialized on component")
+        return None
+
+    return component.data_retention_service
+
+
+def get_task_logger_service(
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+) -> TaskLoggerService:
+    """FastAPI dependency to get an instance of TaskLoggerService."""
+    log.debug("[Dependencies] get_task_logger_service called")
+    task_logger_service = component.get_task_logger_service()
+    if task_logger_service is None:
+        log.error("[Dependencies] TaskLoggerService is not available.")
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Task logging service is not configured or available.",
+        )
+    return task_logger_service
+
+
 PublishFunc = Callable[[str, dict, dict | None], None]
 
 
@@ -304,18 +405,22 @@ class ValidatedUserConfig:
     ) -> dict[str, Any]:
         user_id = user_config.get("user_profile", {}).get("id")
 
-        log.debug(f"[Dependencies] ValidatedUserConfig called for user_id: {user_id} with required scopes: {self.required_scopes}")
+        log.debug(
+            f"[Dependencies] ValidatedUserConfig called for user_id: {user_id} with required scopes: {self.required_scopes}"
+        )
 
         # Validate scopes
         if not config_resolver.is_feature_enabled(
-                user_config, {"tool_metadata": {"required_scopes": self.required_scopes}}, {}
+            user_config,
+            {"tool_metadata": {"required_scopes": self.required_scopes}},
+            {},
         ):
             log.warning(
                 f"[Dependencies] Authorization denied for user '{user_id}'. Required scopes: {self.required_scopes}"
             )
             raise HTTPException(
                 status_code=status.HTTP_403_FORBIDDEN,
-                detail=f"Not authorized. Required scopes: {self.required_scopes}"
+                detail=f"Not authorized. Required scopes: {self.required_scopes}",
             )
 
         return user_config
@@ -396,23 +501,6 @@ def get_task_service(
     )
 
 
-def get_db() -> Generator[Session, None, None]:
-    if SessionLocal is None:
-        raise HTTPException(
-            status_code=status.HTTP_501_NOT_IMPLEMENTED,
-            detail="Session management requires database configuration.",
-        )
-    db = SessionLocal()
-    try:
-        yield db
-        db.commit()
-    except Exception:
-        db.rollback()
-        raise
-    finally:
-        db.close()
-
-
 def get_session_business_service(
     component: "WebUIBackendComponent" = Depends(get_sac_component),
 ) -> SessionService:
@@ -423,8 +511,6 @@ def get_session_business_service(
     return SessionService(component=component)
 
 
-
-
 def get_session_validator(
     component: "WebUIBackendComponent" = Depends(get_sac_component),
 ) -> Callable[[str, str], bool]:
@@ -438,7 +524,9 @@ def get_session_validator(
                 db = SessionLocal()
                 try:
                     session_repository = SessionRepository(db)
-                    session_domain = session_repository.find_user_session(session_id, user_id)
+                    session_domain = session_repository.find_user_session(
+                        session_id, user_id
+                    )
                     return session_domain is not None
                 finally:
                     db.close()
@@ -479,6 +567,8 @@ def get_session_business_service_optional(
 ) -> SessionService | None:
     """Optional session service dependency that returns None if database is not configured."""
     if SessionLocal is None:
-        log.debug("[Dependencies] Database not configured, returning None for session service")
+        log.debug(
+            "[Dependencies] Database not configured, returning None for session service"
+        )
         return None
     return SessionService(component=component)