solace-agent-mesh 1.11.2__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/repository/session_repository.py

@@ -0,0 +1,268 @@
+"""
+Session repository implementation using SQLAlchemy.
+"""
+
+from sqlalchemy import or_, func
+from sqlalchemy.orm import Session as DBSession, joinedload
+
+from ..shared.base_repository import PaginatedRepository
+from ..shared.pagination import PaginationParams
+from ..shared.types import SessionId, UserId
+from ..shared import now_epoch_ms
+from .entities import Session
+from .interfaces import ISessionRepository
+from .models import CreateSessionModel, SessionModel, UpdateSessionModel
+
+
+class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepository):
+    """SQLAlchemy implementation of session repository using BaseRepository."""
+
+    def __init__(self):
+        super().__init__(SessionModel, Session)
+
+    @property
+    def entity_name(self) -> str:
+        """Return the entity name for error messages."""
+        return "session"
+
+    def find_by_user(
+        self, session: DBSession, user_id: UserId, pagination: PaginationParams | None = None, project_id: str | None = None
+    ) -> list[Session]:
+        """Find all sessions for a specific user with optional project filtering."""
+        query = session.query(SessionModel).filter(
+            SessionModel.user_id == user_id,
+            SessionModel.deleted_at.is_(None)  # Exclude soft-deleted sessions
+        )
+
+        # Optional project filtering for project-specific views
+        if project_id is not None:
+            query = query.filter(SessionModel.project_id == project_id)
+
+        # Eager load project relationship
+        query = query.options(joinedload(SessionModel.project))
+        query = query.order_by(SessionModel.updated_time.desc())
+
+        if pagination:
+            query = query.offset(pagination.offset).limit(pagination.page_size)
+
+        models = query.all()
+        return [Session.model_validate(model) for model in models]
+
+    def count_by_user(self, session: DBSession, user_id: UserId, project_id: str | None = None) -> int:
+        """Count total sessions for a specific user with optional project filtering."""
+        query = session.query(SessionModel).filter(
+            SessionModel.user_id == user_id,
+            SessionModel.deleted_at.is_(None)  # Exclude soft-deleted sessions
+        )
+
+        # Optional project filtering for project-specific views
+        if project_id is not None:
+            query = query.filter(SessionModel.project_id == project_id)
+
+        return query.count()
+
+    def find_user_session(
+        self, session: DBSession, session_id: SessionId, user_id: UserId
+    ) -> Session | None:
+        """Find a specific session belonging to a user."""
+        model = (
+            session.query(SessionModel)
+            .filter(
+                SessionModel.id == session_id,
+                SessionModel.user_id == user_id,
+                SessionModel.deleted_at.is_(None)  # Exclude soft-deleted sessions
+            )
+            .first()
+        )
+        return Session.model_validate(model) if model else None
+
+    def save(self, db_session: DBSession, session: Session) -> Session:
+        """Save or update a session."""
+        existing_model = (
+            db_session.query(SessionModel).filter(SessionModel.id == session.id).first()
+        )
+
+        if existing_model:
+            update_model = UpdateSessionModel(
+                name=session.name,
+                agent_id=session.agent_id,
+                project_id=session.project_id,
+                updated_time=session.updated_time,
+            )
+            return self.update(
+                db_session, session.id, update_model.model_dump(exclude_none=True)
+            )
+        else:
+            create_model = CreateSessionModel(
+                id=session.id,
+                name=session.name,
+                user_id=session.user_id,
+                agent_id=session.agent_id,
+                project_id=session.project_id,
+                created_time=session.created_time,
+                updated_time=session.updated_time,
+            )
+            return self.create(db_session, create_model.model_dump())
+
+    def delete(self, db_session: DBSession, session_id: SessionId, user_id: UserId) -> bool:
+        """Delete a session belonging to a user."""
+        # Check if session belongs to user first
+        session_model = (
+            db_session.query(SessionModel)
+            .filter(
+                SessionModel.id == session_id,
+                SessionModel.user_id == user_id,
+            )
+            .first()
+        )
+
+        if not session_model:
+            return False
+
+        # Use BaseRepository delete method
+        super().delete(db_session, session_id)
+        return True
+
+    def soft_delete(self, db_session: DBSession, session_id: SessionId, user_id: UserId) -> bool:
+        """Soft delete a session belonging to a user."""
+        session_model = (
+            db_session.query(SessionModel)
+            .filter(
+                SessionModel.id == session_id,
+                SessionModel.user_id == user_id,
+                SessionModel.deleted_at.is_(None)
+            )
+            .first()
+        )
+
+        if not session_model:
+            return False
+
+        # Perform soft delete
+        session_model.deleted_at = now_epoch_ms()
+        session_model.deleted_by = user_id
+        session_model.updated_time = now_epoch_ms()
+        
+        db_session.flush()
+        return True
+
+    def soft_delete_by_project(self, db_session: DBSession, project_id: str, user_id: UserId) -> int:
+        """
+        Soft delete all sessions belonging to a specific project.
+        Used when cascading project deletion.
+        
+        Args:
+            db_session: Database session
+            project_id: The project ID
+            user_id: The user ID (for deleted_by tracking)
+            
+        Returns:
+            int: Number of sessions soft deleted
+        """
+        now = now_epoch_ms()
+        
+        # Find all non-deleted sessions for this project
+        sessions_to_delete = (
+            db_session.query(SessionModel)
+            .filter(
+                SessionModel.project_id == project_id,
+                SessionModel.user_id == user_id,
+                SessionModel.deleted_at.is_(None)
+            )
+            .all()
+        )
+        
+        # Soft delete each session
+        for session_model in sessions_to_delete:
+            session_model.deleted_at = now
+            session_model.deleted_by = user_id
+            session_model.updated_time = now
+        
+        db_session.flush()
+        return len(sessions_to_delete)
+
+    def move_to_project(
+        self, db_session: DBSession, session_id: SessionId, user_id: UserId, new_project_id: str | None
+    ) -> Session | None:
+        """Move a session to a different project."""
+        session_model = (
+            db_session.query(SessionModel)
+            .filter(
+                SessionModel.id == session_id,
+                SessionModel.user_id == user_id,
+                SessionModel.deleted_at.is_(None)
+            )
+            .first()
+        )
+
+        if not session_model:
+            return None
+
+        # Update project_id
+        session_model.project_id = new_project_id
+        session_model.updated_time = now_epoch_ms()
+        
+        db_session.flush()
+        db_session.refresh(session_model)
+        
+        return Session.model_validate(session_model)
+
+    def search(
+        self,
+        db_session: DBSession,
+        user_id: UserId,
+        query: str,
+        pagination: PaginationParams | None = None,
+        project_id: str | None = None
+    ) -> list[Session]:
+        """
+        Search sessions by name/title only using ILIKE.
+        """
+        # Base query - only non-deleted sessions for the user
+        base_query = db_session.query(SessionModel).filter(
+            SessionModel.user_id == user_id,
+            SessionModel.deleted_at.is_(None)
+        )
+
+        # Optional project filtering
+        if project_id is not None:
+            base_query = base_query.filter(SessionModel.project_id == project_id)
+
+        # ILIKE search on session name
+        search_pattern = f"%{query}%"
+        search_query = base_query.filter(SessionModel.name.ilike(search_pattern))
+
+        # Eager load project relationship
+        search_query = search_query.options(joinedload(SessionModel.project))
+        search_query = search_query.order_by(SessionModel.updated_time.desc())
+
+        if pagination:
+            search_query = search_query.offset(pagination.offset).limit(pagination.page_size)
+
+        models = search_query.all()
+        return [Session.model_validate(model) for model in models]
+
+    def count_search_results(
+        self,
+        db_session: DBSession,
+        user_id: UserId,
+        query: str,
+        project_id: str | None = None
+    ) -> int:
+        """
+        Count search results for pagination (title-only search).
+        """
+        # Base query - only non-deleted sessions for the user
+        base_query = db_session.query(SessionModel).filter(
+            SessionModel.user_id == user_id,
+            SessionModel.deleted_at.is_(None)
+        )
+
+        if project_id is not None:
+            base_query = base_query.filter(SessionModel.project_id == project_id)
+
+        # ILIKE search on session name
+        search_pattern = f"%{query}%"
+        search_query = base_query.filter(SessionModel.name.ilike(search_pattern))
+
+        return search_query.count()

solace_agent_mesh/gateway/http_sse/repository/task_repository.py

@@ -0,0 +1,248 @@
+"""
+Task repository implementation using SQLAlchemy.
+"""
+
+from sqlalchemy.orm import Session as DBSession
+
+from ..shared.pagination import PaginationParams
+from ..shared.types import UserId
+from .entities import Task, TaskEvent
+from .interfaces import ITaskRepository
+from .models import TaskEventModel, TaskModel
+
+
+class TaskRepository(ITaskRepository):
+    """SQLAlchemy implementation of task repository."""
+
+    def save_task(self, session: DBSession, task: Task) -> Task:
+        """Create or update a task."""
+        model = session.query(TaskModel).filter(TaskModel.id == task.id).first()
+
+        if model:
+            model.end_time = task.end_time
+            model.status = task.status
+            model.total_input_tokens = task.total_input_tokens
+            model.total_output_tokens = task.total_output_tokens
+            model.total_cached_input_tokens = task.total_cached_input_tokens
+            model.token_usage_details = task.token_usage_details
+            model.execution_mode = task.execution_mode
+            model.last_activity_time = task.last_activity_time
+            model.background_execution_enabled = task.background_execution_enabled
+            model.max_execution_time_ms = task.max_execution_time_ms
+        else:
+            model = TaskModel(
+                id=task.id,
+                user_id=task.user_id,
+                parent_task_id=task.parent_task_id,
+                start_time=task.start_time,
+                end_time=task.end_time,
+                status=task.status,
+                initial_request_text=task.initial_request_text,
+                total_input_tokens=task.total_input_tokens,
+                total_output_tokens=task.total_output_tokens,
+                total_cached_input_tokens=task.total_cached_input_tokens,
+                token_usage_details=task.token_usage_details,
+                execution_mode=task.execution_mode,
+                last_activity_time=task.last_activity_time,
+                background_execution_enabled=task.background_execution_enabled,
+                max_execution_time_ms=task.max_execution_time_ms,
+            )
+            session.add(model)
+
+        session.flush()
+        session.refresh(model)
+        return self._task_model_to_entity(model)
+
+    def save_event(self, session: DBSession, event: TaskEvent) -> TaskEvent:
+        """Save a task event."""
+        model = TaskEventModel(
+            id=event.id,
+            task_id=event.task_id,
+            user_id=event.user_id,
+            created_time=event.created_time,
+            topic=event.topic,
+            direction=event.direction,
+            payload=event.payload,
+        )
+        session.add(model)
+        session.flush()
+        session.refresh(model)
+        return self._event_model_to_entity(model)
+
+    def find_by_id(self, session: DBSession, task_id: str) -> Task | None:
+        """Find a task by its ID."""
+        model = session.query(TaskModel).filter(TaskModel.id == task_id).first()
+        return self._task_model_to_entity(model) if model else None
+
+    def find_by_id_with_events(
+        self, session: DBSession, task_id: str
+    ) -> tuple[Task, list[TaskEvent]] | None:
+        """Find a task with all its events."""
+        task_model = session.query(TaskModel).filter(TaskModel.id == task_id).first()
+        if not task_model:
+            return None
+
+        event_models = (
+            session.query(TaskEventModel)
+            .filter(TaskEventModel.task_id == task_id)
+            .order_by(TaskEventModel.created_time.asc())
+            .all()
+        )
+
+        task = self._task_model_to_entity(task_model)
+        events = [self._event_model_to_entity(model) for model in event_models]
+        return task, events
+
+    def search(
+        self,
+        session: DBSession,
+        user_id: UserId,
+        start_date: int | None = None,
+        end_date: int | None = None,
+        pagination: PaginationParams | None = None,
+    ) -> list[Task]:
+        """Search for tasks with filters."""
+        query = session.query(TaskModel)
+        if user_id != "*":
+            query = query.filter(TaskModel.user_id == user_id)
+
+        if start_date:
+            query = query.filter(TaskModel.start_time >= start_date)
+        if end_date:
+            query = query.filter(TaskModel.start_time <= end_date)
+
+        query = query.order_by(TaskModel.start_time.desc())
+
+        if pagination:
+            query = query.offset(pagination.offset).limit(pagination.page_size)
+
+        models = query.all()
+        return [self._task_model_to_entity(model) for model in models]
+
+    def delete_tasks_older_than(self, session: DBSession, cutoff_time_ms: int, batch_size: int) -> int:
+        """
+        Delete tasks (and their events via cascade) older than the cutoff time.
+        Uses batch deletion to avoid long-running transactions.
+
+        Args:
+            cutoff_time_ms: Epoch milliseconds - tasks with start_time before this will be deleted
+            batch_size: Number of tasks to delete per batch
+
+        Returns:
+            Total number of tasks deleted
+
+        Note:
+            This method commits each batch internally due to the nature of batch processing.
+            Each batch is an atomic operation to prevent long-running transactions.
+        """
+        total_deleted = 0
+
+        while True:
+            task_ids_to_delete = (
+                session.query(TaskModel.id)
+                .filter(TaskModel.start_time < cutoff_time_ms)
+                .limit(batch_size)
+                .all()
+            )
+
+            if not task_ids_to_delete:
+                break
+
+            ids = [task_id[0] for task_id in task_ids_to_delete]
+
+            deleted_count = (
+                session.query(TaskModel)
+                .filter(TaskModel.id.in_(ids))
+                .delete(synchronize_session=False)
+            )
+
+            session.commit()
+            total_deleted += deleted_count
+
+            if deleted_count < batch_size:
+                break
+
+        return total_deleted
+
+    def find_all_by_parent_chain(self, session: DBSession, task_id: str) -> list[str]:
+        """
+        Returns all task IDs in the hierarchy starting from task_id.
+        Traverses up to find root, then traverses down to find all descendants.
+
+        Args:
+            session: Database session
+            task_id: Starting task ID
+
+        Returns:
+            List of all task IDs in the hierarchy (including the starting task)
+        """
+        # Find root task (traverse up parent chain)
+        root_task_id = task_id
+        current_id = task_id
+        visited = set()
+
+        while current_id and current_id not in visited:
+            visited.add(current_id)
+            task_model = (
+                session.query(TaskModel).filter(TaskModel.id == current_id).first()
+            )
+            if not task_model or not task_model.parent_task_id:
+                root_task_id = current_id
+                break
+            current_id = task_model.parent_task_id
+
+        # Find all descendants of root (BFS)
+        all_task_ids = {root_task_id}
+        to_process = [root_task_id]
+
+        while to_process:
+            current = to_process.pop(0)
+            # Find children
+            children = (
+                session.query(TaskModel)
+                .filter(TaskModel.parent_task_id == current)
+                .all()
+            )
+            for child in children:
+                if child.id not in all_task_ids:
+                    all_task_ids.add(child.id)
+                    to_process.append(child.id)
+
+        return list(all_task_ids)
+
+    def find_background_tasks_by_status(
+        self, session: DBSession, status: str | None = None
+    ) -> list[Task]:
+        """Find all background tasks, optionally filtered by status."""
+        query = session.query(TaskModel).filter(
+            TaskModel.execution_mode == "background"
+        )
+        
+        if status:
+            query = query.filter(TaskModel.status == status)
+        
+        models = query.all()
+        return [self._task_model_to_entity(model) for model in models]
+    
+    def find_timed_out_background_tasks(
+        self, session: DBSession, cutoff_time_ms: int
+    ) -> list[Task]:
+        """Find background tasks that have exceeded their timeout."""
+        models = (
+            session.query(TaskModel)
+            .filter(
+                TaskModel.execution_mode == "background",
+                TaskModel.status.in_(["running", "pending"]),
+                TaskModel.last_activity_time < cutoff_time_ms
+            )
+            .all()
+        )
+        return [self._task_model_to_entity(model) for model in models]
+
+    def _task_model_to_entity(self, model: TaskModel) -> Task:
+        """Convert SQLAlchemy task model to domain entity."""
+        return Task.model_validate(model)
+
+    def _event_model_to_entity(self, model: TaskEventModel) -> TaskEvent:
+        """Convert SQLAlchemy event model to domain entity."""
+        return TaskEvent.model_validate(model)

solace_agent_mesh/gateway/http_sse/routers/__init__.py

@@ -0,0 +1,4 @@
+"""
+This package contains the FastAPI router modules for the HTTP SSE Gateway.
+Each file defines a set of related API endpoints.
+"""

solace_agent_mesh/gateway/http_sse/routers/agent_cards.py

@@ -0,0 +1,74 @@
+"""
+API Router for agent discovery and management.
+"""
+
+import logging
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import Any, Dict, List
+
+from ....common.agent_registry import AgentRegistry
+from ....common.middleware.registry import MiddlewareRegistry
+from a2a.types import AgentCard
+from ..dependencies import get_agent_registry, get_user_config
+
+log = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("/agentCards", response_model=List[AgentCard])
+async def get_discovered_agent_cards(
+    agent_registry: AgentRegistry = Depends(get_agent_registry),
+    user_config: Dict[str, Any] = Depends(get_user_config),
+):
+    """
+    Retrieves a list of discovered A2A agents filtered by user permissions.
+
+    Agents are filtered based on the user's agent:*:delegate scopes to ensure
+    users only see agents they have permission to access.
+    """
+    log_prefix = "[GET /api/v1/agentCards] "
+    log.info("%sRequest received.", log_prefix)
+    try:
+        agent_names = agent_registry.get_agent_names()
+        all_agents = [
+            agent_registry.get_agent(name)
+            for name in agent_names
+            if agent_registry.get_agent(name)
+        ]
+
+        # Filter agents by user's access permissions
+        config_resolver = MiddlewareRegistry.get_config_resolver()
+        filtered_agents = []
+
+        for agent in all_agents:
+            operation_spec = {
+                "operation_type": "agent_access",
+                "target_agent": agent.name,
+            }
+            validation_result = config_resolver.validate_operation_config(
+                user_config, operation_spec, {"source": "agent_cards_endpoint"}
+            )
+            if validation_result.get("valid", False):
+                filtered_agents.append(agent)
+            else:
+                log.debug(
+                    "%sAgent '%s' filtered out for user. Required scopes: %s",
+                    log_prefix,
+                    agent.name,
+                    validation_result.get("required_scopes", []),
+                )
+
+        log.debug(
+            "%sReturning %d/%d agents after filtering.",
+            log_prefix,
+            len(filtered_agents),
+            len(all_agents),
+        )
+        return filtered_agents
+    except Exception as e:
+        log.exception("%sError retrieving discovered agent cards: %s", log_prefix, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Internal server error retrieving agent list.",
+        )