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

solace_agent_mesh/gateway/http_sse/services/data_retention_service.py

@@ -0,0 +1,272 @@
+"""
+Service for managing automatic cleanup of old data based on retention policies.
+"""
+
+import time
+from typing import Any, Callable, Dict
+
+from solace_ai_connector.common.log import log
+from sqlalchemy.orm import Session as DBSession
+
+from ..repository.feedback_repository import FeedbackRepository
+from ..repository.task_repository import TaskRepository
+from ..shared import now_epoch_ms
+
+
+class DataRetentionService:
+    """
+    Service for automatically cleaning up old tasks, task events, and feedback
+    based on configurable retention policies.
+    """
+
+    # Validation constants
+    MIN_RETENTION_DAYS = 1
+    MIN_CLEANUP_INTERVAL_HOURS = 1
+    MIN_BATCH_SIZE = 1
+    MAX_BATCH_SIZE = 10000
+
+    def __init__(
+        self, session_factory: Callable[[], DBSession] | None, config: Dict[str, Any]
+    ):
+        """
+        Initialize the DataRetentionService.
+
+        Args:
+            session_factory: Factory function to create database sessions
+            config: Configuration dictionary with retention settings
+        """
+        self.session_factory = session_factory
+        self.config = config
+        self.log_identifier = "[DataRetentionService]"
+
+        # Validate and store configuration
+        self._validate_config()
+
+        log.info(
+            "%s Initialized with task_retention=%d days, feedback_retention=%d days, "
+            "cleanup_interval=%d hours, batch_size=%d",
+            self.log_identifier,
+            self.config.get("task_retention_days"),
+            self.config.get("feedback_retention_days"),
+            self.config.get("cleanup_interval_hours"),
+            self.config.get("batch_size"),
+        )
+
+    def _validate_config(self) -> None:
+        """
+        Validates configuration values and applies safe defaults if needed.
+        Logs warnings for invalid values.
+        """
+        # Validate task retention days
+        task_retention = self.config.get("task_retention_days", 90)
+        if task_retention < self.MIN_RETENTION_DAYS:
+            log.warning(
+                "%s task_retention_days (%d) is below minimum (%d days). Using minimum.",
+                self.log_identifier,
+                task_retention,
+                self.MIN_RETENTION_DAYS,
+            )
+            self.config["task_retention_days"] = self.MIN_RETENTION_DAYS
+        else:
+            self.config["task_retention_days"] = task_retention
+
+        # Validate feedback retention days
+        feedback_retention = self.config.get("feedback_retention_days", 90)
+        if feedback_retention < self.MIN_RETENTION_DAYS:
+            log.warning(
+                "%s feedback_retention_days (%d) is below minimum (%d days). Using minimum.",
+                self.log_identifier,
+                feedback_retention,
+                self.MIN_RETENTION_DAYS,
+            )
+            self.config["feedback_retention_days"] = self.MIN_RETENTION_DAYS
+        else:
+            self.config["feedback_retention_days"] = feedback_retention
+
+        # Validate cleanup interval
+        cleanup_interval = self.config.get("cleanup_interval_hours", 24)
+        if cleanup_interval < self.MIN_CLEANUP_INTERVAL_HOURS:
+            log.warning(
+                "%s cleanup_interval_hours (%d) is below minimum (%d hours). Using minimum.",
+                self.log_identifier,
+                cleanup_interval,
+                self.MIN_CLEANUP_INTERVAL_HOURS,
+            )
+            self.config["cleanup_interval_hours"] = self.MIN_CLEANUP_INTERVAL_HOURS
+        else:
+            self.config["cleanup_interval_hours"] = cleanup_interval
+
+        # Validate batch size
+        batch_size = self.config.get("batch_size", 1000)
+        if batch_size < self.MIN_BATCH_SIZE:
+            log.warning(
+                "%s batch_size (%d) is below minimum (%d). Using minimum.",
+                self.log_identifier,
+                batch_size,
+                self.MIN_BATCH_SIZE,
+            )
+            self.config["batch_size"] = self.MIN_BATCH_SIZE
+        elif batch_size > self.MAX_BATCH_SIZE:
+            log.warning(
+                "%s batch_size (%d) exceeds maximum (%d). Using maximum.",
+                self.log_identifier,
+                batch_size,
+                self.MAX_BATCH_SIZE,
+            )
+            self.config["batch_size"] = self.MAX_BATCH_SIZE
+        else:
+            self.config["batch_size"] = batch_size
+
+    def cleanup_old_data(self) -> None:
+        """
+        Main orchestration method for cleaning up old data.
+        Calls cleanup methods for tasks and feedback.
+        """
+        if not self.config.get("enabled", True):
+            log.warning(
+                "%s Data retention cleanup is disabled via configuration.",
+                self.log_identifier,
+            )
+            return
+
+        if not self.session_factory:
+            log.warning(
+                "%s No database session factory available. Skipping cleanup.",
+                self.log_identifier,
+            )
+            return
+
+        log.info("%s Starting data retention cleanup...", self.log_identifier)
+        start_time = time.time()
+
+        try:
+            # Cleanup old tasks
+            task_retention_days = self.config.get("task_retention_days")
+            tasks_deleted = self._cleanup_old_tasks(task_retention_days)
+
+            # Cleanup old feedback
+            feedback_retention_days = self.config.get("feedback_retention_days")
+            feedback_deleted = self._cleanup_old_feedback(feedback_retention_days)
+
+            elapsed_time = time.time() - start_time
+            log.info(
+                "%s Cleanup completed. Tasks deleted: %d, Feedback deleted: %d, Time taken: %.2f seconds",
+                self.log_identifier,
+                tasks_deleted,
+                feedback_deleted,
+                elapsed_time,
+            )
+
+        except Exception as e:
+            log.error(
+                "%s Error during data retention cleanup: %s",
+                self.log_identifier,
+                e,
+                exc_info=True,
+            )
+
+    def _cleanup_old_tasks(self, retention_days: int) -> int:
+        """
+        Deletes tasks (and their events via cascade) older than the retention period.
+
+        Args:
+            retention_days: Number of days to retain tasks
+
+        Returns:
+            Total number of tasks deleted
+        """
+        log.info(
+            "%s Cleaning up tasks older than %d days...",
+            self.log_identifier,
+            retention_days,
+        )
+
+        # Calculate cutoff time in milliseconds
+        cutoff_time_ms = now_epoch_ms() - (retention_days * 24 * 60 * 60 * 1000)
+        batch_size = self.config.get("batch_size")
+
+        db = self.session_factory()
+        try:
+            repo = TaskRepository(db)
+            total_deleted = repo.delete_tasks_older_than(cutoff_time_ms, batch_size)
+
+            if total_deleted == 0:
+                log.info(
+                    "%s No tasks found older than %d days.",
+                    self.log_identifier,
+                    retention_days,
+                )
+            else:
+                log.info(
+                    "%s Deleted %d tasks older than %d days.",
+                    self.log_identifier,
+                    total_deleted,
+                    retention_days,
+                )
+
+            return total_deleted
+
+        except Exception as e:
+            log.error(
+                "%s Error cleaning up old tasks: %s",
+                self.log_identifier,
+                e,
+                exc_info=True,
+            )
+            db.rollback()
+            return 0
+        finally:
+            db.close()
+
+    def _cleanup_old_feedback(self, retention_days: int) -> int:
+        """
+        Deletes feedback records older than the retention period.
+
+        Args:
+            retention_days: Number of days to retain feedback
+
+        Returns:
+            Total number of feedback records deleted
+        """
+        log.info(
+            "%s Cleaning up feedback older than %d days...",
+            self.log_identifier,
+            retention_days,
+        )
+
+        # Calculate cutoff time in milliseconds
+        cutoff_time_ms = now_epoch_ms() - (retention_days * 24 * 60 * 60 * 1000)
+        batch_size = self.config.get("batch_size")
+
+        db = self.session_factory()
+        try:
+            repo = FeedbackRepository(db)
+            total_deleted = repo.delete_feedback_older_than(cutoff_time_ms, batch_size)
+
+            if total_deleted == 0:
+                log.info(
+                    "%s No feedback found older than %d days.",
+                    self.log_identifier,
+                    retention_days,
+                )
+            else:
+                log.info(
+                    "%s Deleted %d feedback records older than %d days.",
+                    self.log_identifier,
+                    total_deleted,
+                    retention_days,
+                )
+
+            return total_deleted
+
+        except Exception as e:
+            log.error(
+                "%s Error cleaning up old feedback: %s",
+                self.log_identifier,
+                e,
+                exc_info=True,
+            )
+            db.rollback()
+            return 0
+        finally:
+            db.close()

solace_agent_mesh/gateway/http_sse/services/feedback_service.py

@@ -0,0 +1,241 @@
+"""
+Service layer for handling user feedback on chat messages.
+"""
+
+import json
+import uuid
+from typing import TYPE_CHECKING, Callable
+
+from solace_ai_connector.common.log import log
+from sqlalchemy.orm import Session as DBSession
+
+from ..repository.entities import Feedback
+from ..repository.feedback_repository import FeedbackRepository
+from ..shared import now_epoch_ms
+from ..utils.stim_utils import create_stim_from_task_data
+
+# The FeedbackPayload is defined in the router, this creates a forward reference
+# which is resolved at runtime.
+if TYPE_CHECKING:
+    from ..routers.feedback import FeedbackPayload
+    from ..component import WebUIBackendComponent
+    from ..repository.interfaces import ITaskRepository
+
+
+class FeedbackService:
+    """Handles the business logic for processing user feedback."""
+
+    def __init__(
+        self,
+        session_factory: Callable[[], DBSession] | None,
+        component: "WebUIBackendComponent",
+        task_repo: "ITaskRepository",
+    ):
+        """Initializes the FeedbackService."""
+        self.session_factory = session_factory
+        self.component = component
+        self.task_repo = task_repo
+        if self.session_factory:
+            log.info("FeedbackService initialized with database persistence.")
+        else:
+            log.info(
+                "FeedbackService initialized without database persistence (logging only)."
+            )
+
+    async def process_feedback(self, payload: "FeedbackPayload", user_id: str):
+        """
+        Processes and stores the feedback. If a repository is configured,
+        it saves to the database. Otherwise, it logs the feedback.
+        Also publishes feedback to a Solace topic if configured.
+        Additionally updates the corresponding task's metadata with the feedback.
+        """
+        if self.session_factory:
+            task_id = getattr(payload, "task_id", None)
+            if not task_id:
+                log.error(
+                    "Feedback payload is missing 'task_id'. Cannot save to database. Payload: %s",
+                    payload.model_dump_json(by_alias=True),
+                )
+                # We can still try to publish the event without saving to DB
+            else:
+                feedback_entity = Feedback(
+                    id=str(uuid.uuid4()),
+                    session_id=payload.session_id,
+                    task_id=task_id,
+                    user_id=user_id,
+                    rating=payload.feedback_type,
+                    comment=payload.feedback_text,
+                    created_time=now_epoch_ms(),
+                )
+
+                db = self.session_factory()
+                try:
+                    repo = FeedbackRepository(db)
+                    repo.save(feedback_entity)
+                    db.commit()
+                    log.info(
+                        "Feedback from user '%s' for task '%s' saved to database.",
+                        user_id,
+                        task_id,
+                    )
+                except Exception as e:
+                    log.exception(
+                        "Failed to save feedback for user '%s' to database: %s",
+                        user_id,
+                        e,
+                    )
+                    db.rollback()
+                finally:
+                    db.close()
+
+                # Update task metadata with feedback
+                self._update_task_metadata_with_feedback(
+                    task_id, user_id, payload.feedback_type, payload.feedback_text
+                )
+        else:
+            log.warning(
+                "Feedback received but no database repository is configured. "
+                "Logging feedback only. Payload: %s",
+                payload.model_dump_json(by_alias=True),
+            )
+
+        # --- New event publishing logic ---
+        try:
+            await self._publish_feedback_event(payload, user_id)
+        except Exception as e:
+            log.error(
+                "Failed to publish feedback event for user '%s': %s", user_id, e
+            )
+            # Do not re-raise, as the primary operation (DB save) may have succeeded.
+
+    def _update_task_metadata_with_feedback(
+        self, task_id: str, user_id: str, feedback_type: str, feedback_text: str | None
+    ):
+        """
+        Update the task's metadata with feedback information.
+        
+        Args:
+            task_id: The task ID to update
+            user_id: The user ID who submitted feedback
+            feedback_type: Type of feedback ("up" or "down")
+            feedback_text: Optional feedback text
+        """
+        if not self.session_factory:
+            log.debug(
+                "No session factory available, skipping task metadata update for task %s",
+                task_id
+            )
+            return
+
+        db = self.session_factory()
+        try:
+            from ..repository.chat_task_repository import ChatTaskRepository
+            
+            task_repo = ChatTaskRepository(db)
+            task = task_repo.find_by_id(task_id, user_id)
+            
+            if task:
+                # Update feedback in task metadata
+                task.add_feedback(feedback_type, feedback_text)
+                task_repo.save(task)
+                db.commit()
+                log.info(
+                    "Updated task metadata with feedback for task '%s' by user '%s'",
+                    task_id,
+                    user_id
+                )
+            else:
+                log.warning(
+                    "Task '%s' not found for user '%s', cannot update task metadata with feedback",
+                    task_id,
+                    user_id
+                )
+        except Exception as e:
+            log.warning(
+                "Failed to update task metadata with feedback for task '%s': %s",
+                task_id,
+                e
+            )
+            db.rollback()
+            # Don't re-raise - feedback was already saved to feedback table
+        finally:
+            db.close()
+
+    async def _publish_feedback_event(self, payload: "FeedbackPayload", user_id: str):
+        """Publishes the feedback as an event to the message broker if configured."""
+        log_id = f"[FeedbackPublisher:{payload.task_id}]"
+        config = self.component.get_config("feedback_publishing", {})
+
+        if not config.get("enabled", False):
+            log.debug("%s Feedback publishing is disabled. Skipping.", log_id)
+            return
+
+        # Construct base payload
+        event_payload = {
+            "feedback": {
+                "task_id": payload.task_id,
+                "session_id": payload.session_id,
+                "feedback_type": payload.feedback_type,
+                "feedback_text": payload.feedback_text,
+                "user_id": user_id,
+            }
+        }
+
+        include_task_info = config.get("include_task_info", "none")
+        task_summary_data = None
+
+        if include_task_info == "summary":
+            log.debug("%s Including task summary.", log_id)
+            task_summary_data = self.task_repo.find_by_id(payload.task_id)
+            if task_summary_data:
+                event_payload["task_summary"] = task_summary_data.model_dump()
+
+        elif include_task_info == "stim":
+            log.debug("%s Including task stim data.", log_id)
+            task_with_events = self.task_repo.find_by_id_with_events(payload.task_id)
+            if task_with_events:
+                task, events = task_with_events
+                stim_data = create_stim_from_task_data(task, events)
+                event_payload["task_stim_data"] = stim_data
+
+                # Check payload size
+                max_size = config.get("max_payload_size_bytes", 9000000)
+                try:
+                    payload_bytes = json.dumps(event_payload).encode("utf-8")
+                    if len(payload_bytes) > max_size:
+                        log.warning(
+                            "%s Stim payload size (%d bytes) exceeds limit (%d bytes). Falling back to summary.",
+                            log_id,
+                            len(payload_bytes),
+                            max_size,
+                        )
+                        # Fallback to summary
+                        del event_payload["task_stim_data"]
+                        task_summary_data = self.task_repo.find_by_id(payload.task_id)
+                        if task_summary_data:
+                            event_payload[
+                                "task_summary"
+                            ] = task_summary_data.model_dump()
+                        event_payload["truncation_details"] = {
+                            "strategy": "fallback_to_summary",
+                            "reason": "payload_too_large",
+                        }
+                except Exception as e:
+                    log.error("%s Error checking payload size: %s", log_id, e)
+                    # If we can't check size, better to not send a potentially huge message
+                    if "task_stim_data" in event_payload:
+                        del event_payload["task_stim_data"]
+
+        # Publish the event
+        topic = config.get("topic", "sam/feedback/v1")
+        try:
+            log.info("%s Publishing feedback event to topic '%s'", log_id, topic)
+            self.component.publish_a2a(topic, event_payload)
+        except Exception as e:
+            log.error(
+                "%s Failed to publish feedback event to topic '%s': %s",
+                log_id,
+                topic,
+                e,
+            )
+            # Don't re-raise, this is a non-critical operation.

solace_agent_mesh/gateway/http_sse/services/people_service.py

@@ -9,86 +9,6 @@ from solace_ai_connector.common.log import log
 from ....common.services.identity_service import BaseIdentityService
 
 
-class PeopleService:
-    """
-    Provides methods for searching and retrieving user information,
-    acting as a layer on top of the configured IdentityService.
-    """
-
-    def __init__(self, identity_service: Optional[BaseIdentityService]):
-        """
-        Initializes the PeopleService.
-
-        Args:
-            identity_service: An instance of a configured BaseIdentityService, or None.
-        """
-        self._identity_service = identity_service
-        self.log_identifier = "[PeopleService]"
-        log.info(
-            "%s Initialized with Identity Service: %s",
-            self.log_identifier,
-            identity_service is not None,
-        )
-
-    async def search_for_users(
-        self, query: str, limit: int = 10
-    ) -> List[Dict[str, Any]]:
-        """
-        Searches for users via the identity service.
-
-        Args:
-            query: The search query string.
-            limit: The maximum number of results to return.
-
-        Returns:
-            A list of user profile dictionaries.
-        """
-        if not self._identity_service:
-            log.warning(
-                "%s Search requested but no identity service is configured.",
-                self.log_identifier,
-            )
-            return []
-
-        if not query or len(query) < 2:
-            return []
-
-        try:
-            log.debug(
-                "%s Searching for users with query: '%s', limit: %d",
-                self.log_identifier,
-                query,
-                limit,
-            )
-            results = await self._identity_service.search_users(query, limit)
-            log.info(
-                "%s Found %d users for query: '%s'",
-                self.log_identifier,
-                len(results),
-                query,
-            )
-            return results
-        except Exception as e:
-            log.exception(
-                "%s Error during user search for query '%s': %s",
-                self.log_identifier,
-                query,
-                e,
-            )
-            return []
-
-
-"""
-Service layer for handling people-related operations, such as searching for users.
-"""
-
-from typing import Any, Dict, List, Optional
-
-from solace_ai_connector.common.log import log
-
-from ....common.services.identity_service import BaseIdentityService
-
-
 class PeopleService:
     """
     Provides methods for searching and retrieving user information,