solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/repository/session_repository.py

@@ -2,11 +2,13 @@
 Session repository implementation using SQLAlchemy.
 """
 
-from sqlalchemy.orm import Session as DBSession
+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 solace_agent_mesh.shared.database.base_repository import PaginatedRepository
+from solace_agent_mesh.shared.api.pagination import PaginationParams
+from solace_agent_mesh.shared.utils.types import SessionId, UserId
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
 from .entities import Session
 from .interfaces import ISessionRepository
 from .models import CreateSessionModel, SessionModel, UpdateSessionModel
@@ -24,10 +26,20 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         return "session"
 
     def find_by_user(
-        self, session: DBSession, user_id: UserId, pagination: PaginationParams | None = None
+        self, session: DBSession, user_id: UserId, pagination: PaginationParams | None = None, project_id: str | None = None
     ) -> list[Session]:
-        """Find all sessions for a specific user."""
-        query = session.query(SessionModel).filter(SessionModel.user_id == user_id)
+        """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:
@@ -36,12 +48,19 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         models = query.all()
         return [Session.model_validate(model) for model in models]
 
-    def count_by_user(self, session: DBSession, user_id: UserId) -> int:
-        """Count total sessions for a specific user."""
-        return (
-            session.query(SessionModel).filter(SessionModel.user_id == user_id).count()
+    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:
@@ -51,6 +70,7 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
             .filter(
                 SessionModel.id == session_id,
                 SessionModel.user_id == user_id,
+                SessionModel.deleted_at.is_(None)  # Exclude soft-deleted sessions
             )
             .first()
         )
@@ -66,6 +86,7 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
             update_model = UpdateSessionModel(
                 name=session.name,
                 agent_id=session.agent_id,
+                project_id=session.project_id,
                 updated_time=session.updated_time,
             )
             return self.update(
@@ -77,6 +98,7 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
                 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,
             )
@@ -100,3 +122,147 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         # 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

@@ -4,8 +4,8 @@ Task repository implementation using SQLAlchemy.
 
 from sqlalchemy.orm import Session as DBSession
 
-from ..shared.pagination import PaginationParams
-from ..shared.types import UserId
+from solace_agent_mesh.shared.api.pagination import PaginationParams
+from solace_agent_mesh.shared.utils.types import UserId
 from .entities import Task, TaskEvent
 from .interfaces import ITaskRepository
 from .models import TaskEventModel, TaskModel
@@ -25,10 +25,15 @@ class TaskRepository(ITaskRepository):
             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,
@@ -37,6 +42,10 @@ class TaskRepository(ITaskRepository):
                 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)
 
@@ -155,6 +164,81 @@ class TaskRepository(ITaskRepository):
 
         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)

solace_agent_mesh/gateway/http_sse/routers/agent_cards.py

@@ -4,12 +4,12 @@ API Router for agent discovery and management.
 
 import logging
 from fastapi import APIRouter, Depends, HTTPException, status
-from typing import Dict, List
+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_sac_component
-from ..component import WebUIBackendComponent
+from ..dependencies import get_agent_registry, get_user_config
 
 log = logging.getLogger(__name__)
 
@@ -19,22 +19,53 @@ 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 all currently discovered A2A agents' cards.
+    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()
-        agents = [
+        all_agents = [
             agent_registry.get_agent(name)
             for name in agent_names
             if agent_registry.get_agent(name)
         ]
 
-        log.info("%sReturning %d discovered agent cards.", log_prefix, len(agents))
-        return agents
+        # 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(