solace-agent-mesh 1.4.12__py3-none-any.whl → 1.5.1__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -2,20 +2,28 @@
 API Router for submitting and managing tasks to agents.
 """
 
+import logging
+import yaml
+from datetime import datetime
 from fastapi import (
     APIRouter,
     Depends,
     HTTPException,
     Request as FastAPIRequest,
+    Response,
     status,
 )
-from typing import Union
+from fastapi.exceptions import RequestValidationError
+from typing import List, Optional, Union
 
-from solace_ai_connector.common.log import log
 
 from ....gateway.http_sse.session_manager import SessionManager
 from ....gateway.http_sse.services.task_service import TaskService
 from ....gateway.http_sse.services.session_service import SessionService
+from ....gateway.http_sse.repository.interfaces import ITaskRepository
+from ....gateway.http_sse.repository.entities import Task
+from ....gateway.http_sse.shared.types import PaginationParams, UserId
+from ..utils.stim_utils import create_stim_from_task_data
 
 from a2a.types import (
     CancelTaskRequest,
@@ -31,7 +39,12 @@ from ....gateway.http_sse.dependencies import (
     get_sac_component,
     get_task_service,
     get_session_business_service,
+    get_task_repository,
+    get_user_id,
+    get_user_config,
+    get_session_business_service,
 )
+from ....gateway.http_sse.services.session_service import SessionService
 
 from typing import TYPE_CHECKING
 
@@ -40,6 +53,7 @@ if TYPE_CHECKING:
 
 router = APIRouter()
 
+log = logging.getLogger(__name__)
 
 async def _submit_task(
     request: FastAPIRequest,
@@ -58,7 +72,7 @@ async def _submit_task(
 
     if not agent_name:
         raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Missing 'agent_name' in request payload message metadata.",
         )
 
@@ -120,10 +134,14 @@ async def _submit_task(
                         session_id=session_id,
                     )
                     db.commit()
-                    log.info("%sCreated session in database: %s", log_prefix, session_id)
+                    log.info(
+                        "%sCreated session in database: %s", log_prefix, session_id
+                    )
                 except Exception as e:
                     db.rollback()
-                    log.warning("%sFailed to create session in database: %s", log_prefix, e)
+                    log.warning(
+                        "%sFailed to create session in database: %s", log_prefix, e
+                    )
                 finally:
                     db.close()
 
@@ -131,43 +149,6 @@ async def _submit_task(
             "%sUsing ClientID: %s, SessionID: %s", log_prefix, client_id, session_id
         )
 
-        # Store message in persistence layer if available
-        if is_streaming and SessionLocal is not None and session_service is not None:
-            db = SessionLocal()
-            try:
-                from ....gateway.http_sse.shared.enums import SenderType
-
-                message_text = ""
-                if payload.params and payload.params.message:
-                    parts = a2a.get_parts_from_message(payload.params.message)
-                    for part in parts:
-                        if hasattr(part, "text"):
-                            message_text = part.text
-                            break
-
-                session_service.add_message_to_session(
-                    db=db,
-                    session_id=session_id,
-                    user_id=user_id,
-                    message=message_text or "Task submitted",
-                    sender_type=SenderType.USER,
-                    sender_name=user_id or "user",
-                    agent_id=agent_name,
-                )
-                db.commit()
-            except Exception as e:
-                db.rollback()
-                log.error(
-                    "%sFailed to store message in session service: %s", log_prefix, e
-                )
-            finally:
-                db.close()
-        else:
-            log.debug(
-                "%sNo persistence available or non-streaming - skipping message storage",
-                log_prefix,
-            )
-
         # Use the helper to get the unwrapped parts from the incoming message.
         a2a_parts = a2a.get_parts_from_message(payload.params.message)
 
@@ -222,6 +203,146 @@ async def _submit_task(
         )
 
 
+@router.get("/tasks", response_model=List[Task], tags=["Tasks"])
+async def search_tasks(
+    request: FastAPIRequest,
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    search: Optional[str] = None,
+    page: int = 1,
+    page_size: int = 20,
+    query_user_id: Optional[str] = None,
+    user_id: UserId = Depends(get_user_id),
+    user_config: dict = Depends(get_user_config),
+    repo: ITaskRepository = Depends(get_task_repository),
+):
+    """
+    Lists and searches for historical tasks.
+    - Regular users can only search their own tasks.
+    - Users with the 'tasks:read:all' scope can search for any user's tasks by providing `query_user_id`.
+    """
+    log_prefix = f"[GET /api/v1/tasks] "
+    log.info("%sRequest from user %s", log_prefix, user_id)
+
+    target_user_id = user_id
+    can_query_all = user_config.get("scopes", {}).get("tasks:read:all", False)
+
+    if query_user_id:
+        if can_query_all:
+            target_user_id = query_user_id
+            log.info(
+                "%sAdmin user %s is querying for user %s",
+                log_prefix,
+                user_id,
+                target_user_id,
+            )
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="You do not have permission to query for other users' tasks.",
+            )
+    elif can_query_all:
+        target_user_id = "*"
+        log.info("%sAdmin user %s is querying for all users.", log_prefix, user_id)
+
+    start_time_ms = None
+    if start_date:
+        try:
+            start_time_ms = int(datetime.fromisoformat(start_date).timestamp() * 1000)
+        except ValueError:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid start_date format. Use ISO 8601 format.",
+            )
+
+    end_time_ms = None
+    if end_date:
+        try:
+            end_time_ms = int(datetime.fromisoformat(end_date).timestamp() * 1000)
+        except ValueError:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid end_date format. Use ISO 8601 format.",
+            )
+
+    pagination = PaginationParams(page=page, page_size=page_size)
+
+    try:
+        tasks = repo.search(
+            user_id=target_user_id,
+            start_date=start_time_ms,
+            end_date=end_time_ms,
+            search_query=search,
+            pagination=pagination,
+        )
+        return tasks
+    except Exception as e:
+        log.exception("%sError searching for tasks: %s", log_prefix, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An error occurred while searching for tasks.",
+        )
+
+
+@router.get("/tasks/{task_id}", tags=["Tasks"])
+async def get_task_as_stim_file(
+    task_id: str,
+    request: FastAPIRequest,
+    user_id: UserId = Depends(get_user_id),
+    user_config: dict = Depends(get_user_config),
+    repo: ITaskRepository = Depends(get_task_repository),
+):
+    """
+    Retrieves the complete event history for a single task and returns it as a `.stim` file.
+    """
+    log_prefix = f"[GET /api/v1/tasks/{task_id}] "
+    log.info("%sRequest from user %s", log_prefix, user_id)
+
+    try:
+        result = repo.find_by_id_with_events(task_id)
+        if not result:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Task with ID '{task_id}' not found.",
+            )
+
+        task, events = result
+
+        can_read_all = user_config.get("scopes", {}).get("tasks:read:all", False)
+        if task.user_id != user_id and not can_read_all:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="You do not have permission to view this task.",
+            )
+
+        # Format into .stim structure
+        stim_data = create_stim_from_task_data(task, events)
+
+        yaml_content = yaml.dump(
+            stim_data,
+            sort_keys=False,
+            allow_unicode=True,
+            indent=2,
+            default_flow_style=False,
+        )
+
+        return Response(
+            content=yaml_content,
+            media_type="application/x-yaml",
+            headers={"Content-Disposition": f'attachment; filename="{task_id}.stim"'},
+        )
+
+    except HTTPException:
+        # Re-raise HTTPExceptions (404, 403, etc.) without modification
+        raise
+    except Exception as e:
+        log.exception("%sError retrieving task: %s", log_prefix, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An error occurred while retrieving the task.",
+        )
+
+
 @router.post("/message:send", response_model=SendMessageSuccessResponse)
 async def send_task_to_agent(
     request: FastAPIRequest,
@@ -278,6 +399,7 @@ async def cancel_agent_task(
     """
     Sends a cancellation request for a specific task to the specified agent.
     Returns 202 Accepted, as cancellation is asynchronous.
+    Returns 404 if the task context is not found.
     """
     log_prefix = f"[POST /api/v1/tasks/{taskId}:cancel] "
     log.info("%sReceived cancellation request.", log_prefix)
@@ -290,6 +412,11 @@ async def cancel_agent_task(
 
     context = component.task_context_manager.get_context(taskId)
     if not context:
+        log.warning(
+            "%sNo active task context found for task ID: %s",
+            log_prefix,
+            taskId,
+        )
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail=f"No active task context found for task ID: {taskId}",
@@ -328,4 +455,4 @@ async def cancel_agent_task(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=error_resp.model_dump(exclude_none=True),
-        )
+        )

solace_agent_mesh/gateway/http_sse/routers/users.py

@@ -3,13 +3,15 @@ Router for user-related endpoints.
 Maintains backward compatibility with original API format.
 """
 
+import logging
 from typing import Any
 
 from fastapi import APIRouter, Depends
-from solace_ai_connector.common.log import log
 
 from ..shared.auth_utils import get_current_user
 
+log = logging.getLogger(__name__)
+
 router = APIRouter()
 
 

solace_agent_mesh/gateway/http_sse/routers/visualization.py

@@ -2,6 +2,7 @@
 API Router for managing A2A message visualization streams.
 """
 
+import logging
 import asyncio
 import uuid
 from fastapi import (
@@ -15,7 +16,6 @@ from fastapi import (
 from pydantic import BaseModel, Field
 from typing import List, Optional, Dict, Any, Set
 
-from solace_ai_connector.common.log import log
 
 from ....gateway.http_sse.dependencies import (
     get_sac_component,
@@ -30,6 +30,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from ....gateway.http_sse.component import WebUIBackendComponent
 
+log = logging.getLogger(__name__)
 
 router = APIRouter()
 

solace_agent_mesh/gateway/http_sse/services/agent_card_service.py

@@ -5,7 +5,9 @@ with the AgentRegistry.
 
 from typing import List, Optional
 
-from solace_ai_connector.common.log import log
+import logging
+
+log = logging.getLogger(__name__)
 
 from ....common.agent_registry import AgentRegistry
 from a2a.types import AgentCard

solace_agent_mesh/gateway/http_sse/services/data_retention_service.py

@@ -0,0 +1,273 @@
+"""
+Service for managing automatic cleanup of old data based on retention policies.
+"""
+
+import logging
+import time
+from typing import Any, Callable, Dict
+
+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
+
+log = logging.getLogger(__name__)
+
+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()