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

solace_agent_mesh/gateway/http_sse/repository/entities/project.py

@@ -5,7 +5,7 @@ Project domain entity.
 from typing import Optional
 from pydantic import BaseModel, Field
 
-from ...shared import now_epoch_ms
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
 
 
 class Project(BaseModel):

solace_agent_mesh/gateway/http_sse/repository/entities/project_user.py

@@ -5,7 +5,7 @@ Project user access domain entity.
 from typing import Optional
 from pydantic import BaseModel, Field
 
-from ...shared import now_epoch_ms
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
 
 
 class ProjectUser(BaseModel):

solace_agent_mesh/gateway/http_sse/repository/entities/session.py

@@ -4,8 +4,8 @@ Session domain entity.
 
 from pydantic import BaseModel, ConfigDict
 
-from ...shared import now_epoch_ms
-from ...shared.types import AgentId, SessionId, UserId
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
+from solace_agent_mesh.shared.utils.types import AgentId, SessionId, UserId
 
 
 class Session(BaseModel):
@@ -19,6 +19,7 @@ class Session(BaseModel):
     agent_id: AgentId | None = None
     project_id: str | None = None
     project_name: str | None = None
+    has_running_background_task: bool = False  # Enriched field, not stored in DB
     created_time: int
     updated_time: int | None = None
     deleted_at: int | None = None

solace_agent_mesh/gateway/http_sse/repository/entities/task.py

@@ -10,6 +10,7 @@ class Task(BaseModel):
 
     id: str
     user_id: str
+    parent_task_id: str | None = None
     start_time: int
     end_time: int | None = None
     status: str | None = None
@@ -20,6 +21,12 @@ class Task(BaseModel):
     total_output_tokens: int | None = None
     total_cached_input_tokens: int | None = None
     token_usage_details: dict | None = None
+    
+    # Background task execution fields
+    execution_mode: str | None = "foreground"
+    last_activity_time: int | None = None
+    background_execution_enabled: bool | None = False
+    max_execution_time_ms: int | None = None
 
     class Config:
         from_attributes = True

solace_agent_mesh/gateway/http_sse/repository/feedback_repository.py

@@ -4,8 +4,8 @@ Feedback 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 Feedback
 from .interfaces import IFeedbackRepository
 from .models import FeedbackModel

solace_agent_mesh/gateway/http_sse/repository/interfaces.py

@@ -6,8 +6,8 @@ from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Optional
 from sqlalchemy.orm import Session as DBSession
 
-from ..shared.pagination import PaginationParams
-from ..shared.types import SessionId, UserId
+from solace_agent_mesh.shared.api.pagination import PaginationParams
+from solace_agent_mesh.shared.utils.types import SessionId, UserId
 from .entities import Feedback, Session, Task, TaskEvent
 from .entities.project import Project
 from ..routers.dto.requests.project_requests import ProjectFilter

solace_agent_mesh/gateway/http_sse/repository/models/__init__.py

@@ -10,6 +10,7 @@ from .project_user_model import ProjectUserModel, CreateProjectUserModel, Update
 from .session_model import SessionModel, CreateSessionModel, UpdateSessionModel
 from .task_event_model import TaskEventModel
 from .task_model import TaskModel
+from .prompt_model import PromptGroupModel, PromptModel, PromptGroupUserModel
 
 __all__ = [
     "Base",
@@ -26,4 +27,8 @@ __all__ = [
     "UpdateSessionModel",
     "TaskEventModel",
     "TaskModel",
+    "FeedbackModel",
+    "PromptGroupModel",
+    "PromptModel",
+    "PromptGroupUserModel",
 ]

solace_agent_mesh/gateway/http_sse/repository/models/prompt_model.py

@@ -0,0 +1,159 @@
+"""
+Prompt SQLAlchemy models for prompt library feature.
+"""
+
+from enum import Enum
+from sqlalchemy import BigInteger, Column, String, Text, Integer, Boolean, ForeignKey, UniqueConstraint, Enum as SQLEnum
+from sqlalchemy.orm import relationship
+
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
+from .base import Base
+
+
+class PromptGroupRole(str, Enum):
+    """Valid roles for prompt group users."""
+    OWNER = "owner"
+    EDITOR = "editor"
+    VIEWER = "viewer"
+
+
+class PromptGroupModel(Base):
+    """SQLAlchemy model for prompt groups"""
+    
+    __tablename__ = "prompt_groups"
+    
+    # Primary key - String type (not UUID)
+    id = Column(String, primary_key=True)
+    
+    # Core fields
+    name = Column(String(255), nullable=False, index=True)
+    description = Column(Text, nullable=True)
+    category = Column(String(100), nullable=True, index=True)
+    command = Column(String(50), nullable=True, unique=True, index=True)
+    
+    # Ownership
+    user_id = Column(String, nullable=False, index=True)
+    author_name = Column(String(255), nullable=True)
+    
+    # Production prompt reference
+    production_prompt_id = Column(
+        String, 
+        ForeignKey("prompts.id", ondelete="SET NULL"), 
+        nullable=True
+    )
+    
+    # Sharing (optional - for future enhancement)
+    is_shared = Column(Boolean, default=False, nullable=False)
+    
+    # User preferences
+    is_pinned = Column(Boolean, default=False, nullable=False, index=True)
+    
+    # Timestamps - BigInteger (epoch milliseconds) to match SAM convention
+    created_at = Column(BigInteger, nullable=False, default=now_epoch_ms)
+    updated_at = Column(
+        BigInteger, 
+        nullable=False, 
+        default=now_epoch_ms, 
+        onupdate=now_epoch_ms
+    )
+    
+    # Relationships
+    prompts = relationship(
+        "PromptModel",
+        back_populates="group",
+        foreign_keys="PromptModel.group_id",
+        cascade="all, delete-orphan"
+    )
+    production_prompt = relationship(
+        "PromptModel",
+        foreign_keys=[production_prompt_id],
+        post_update=True
+    )
+    prompt_group_users = relationship(
+        "PromptGroupUserModel",
+        back_populates="prompt_group",
+        cascade="all, delete-orphan"
+    )
+    
+    def __repr__(self):
+        return f"<PromptGroupModel(id={self.id}, name={self.name}, command={self.command})>"
+
+
+class PromptModel(Base):
+    """SQLAlchemy model for individual prompt versions"""
+    
+    __tablename__ = "prompts"
+    
+    # Primary key - String type (not UUID)
+    id = Column(String, primary_key=True)
+    
+    # Content
+    prompt_text = Column(Text, nullable=False)
+    
+    # Versioned metadata fields (copied from group at version creation time)
+    name = Column(String(255), nullable=True)
+    description = Column(Text, nullable=True)
+    category = Column(String(100), nullable=True)
+    command = Column(String(50), nullable=True)
+    
+    # Group relationship
+    group_id = Column(
+        String,
+        ForeignKey("prompt_groups.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True
+    )
+    
+    # Ownership
+    user_id = Column(String, nullable=False, index=True)
+    
+    # Versioning
+    version = Column(Integer, default=1, nullable=False)
+    
+    # Timestamps - BigInteger (epoch milliseconds)
+    created_at = Column(BigInteger, nullable=False, default=now_epoch_ms)
+    updated_at = Column(
+        BigInteger,
+        nullable=False,
+        default=now_epoch_ms,
+        onupdate=now_epoch_ms
+    )
+    
+    # Relationships
+    group = relationship(
+        "PromptGroupModel",
+        back_populates="prompts",
+        foreign_keys=[group_id]
+    )
+    
+    def __repr__(self):
+        return f"<PromptModel(id={self.id}, group_id={self.group_id}, version={self.version})>"
+
+
+class PromptGroupUserModel(Base):
+    """
+    SQLAlchemy model for prompt group user access.
+    
+    This junction table tracks which users have access to which prompt groups,
+    enabling multi-user collaboration on prompts with role-based permissions.
+    """
+    
+    __tablename__ = "prompt_group_users"
+    
+    id = Column(String, primary_key=True)
+    prompt_group_id = Column(String, ForeignKey("prompt_groups.id", ondelete="CASCADE"), nullable=False)
+    user_id = Column(String, nullable=False)
+    role = Column(SQLEnum(PromptGroupRole), nullable=False, default=PromptGroupRole.VIEWER)
+    added_at = Column(BigInteger, nullable=False)  # Epoch timestamp in milliseconds
+    added_by_user_id = Column(String, nullable=False)  # User who granted access
+    
+    # Ensure a user can only be added once per prompt group
+    __table_args__ = (
+        UniqueConstraint('prompt_group_id', 'user_id', name='uq_prompt_group_user'),
+    )
+    
+    # Relationships
+    prompt_group = relationship("PromptGroupModel", back_populates="prompt_group_users")
+    
+    def __repr__(self):
+        return f"<PromptGroupUserModel(id={self.id}, prompt_group_id={self.prompt_group_id}, user_id={self.user_id}, role={self.role})>"

solace_agent_mesh/gateway/http_sse/repository/models/session_model.py

@@ -6,7 +6,7 @@ from sqlalchemy import BigInteger, Column, String, ForeignKey
 from pydantic import BaseModel
 from sqlalchemy.orm import relationship
 
-from ...shared import now_epoch_ms
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
 from .base import Base
 
 

solace_agent_mesh/gateway/http_sse/repository/models/task_model.py

@@ -2,7 +2,7 @@
 Task SQLAlchemy model.
 """
 
-from sqlalchemy import BigInteger, Column, Integer, JSON, String, Text
+from sqlalchemy import BigInteger, Boolean, Column, Integer, JSON, String, Text
 from sqlalchemy.orm import relationship
 
 from .base import Base
@@ -15,6 +15,7 @@ class TaskModel(Base):
 
     id = Column(String, primary_key=True)
     user_id = Column(String, nullable=False, index=True)
+    parent_task_id = Column(String, nullable=True, index=True)
     start_time = Column(BigInteger, nullable=False)
     end_time = Column(BigInteger, nullable=True)
     status = Column(String, nullable=True)
@@ -25,6 +26,12 @@ class TaskModel(Base):
     total_output_tokens = Column(Integer, nullable=True)
     total_cached_input_tokens = Column(Integer, nullable=True)
     token_usage_details = Column(JSON, nullable=True)
+    
+    # Background task execution columns
+    execution_mode = Column(String(20), nullable=True, default="foreground", index=True)
+    last_activity_time = Column(BigInteger, nullable=True, index=True)
+    background_execution_enabled = Column(Boolean, nullable=True, default=False)
+    max_execution_time_ms = Column(BigInteger, nullable=True)
 
     # Relationship to events
     events = relationship(

solace_agent_mesh/gateway/http_sse/repository/project_repository.py

@@ -11,7 +11,7 @@ from .interfaces import IProjectRepository
 from .models import ProjectModel, ProjectUserModel
 from .entities.project import Project
 from ..routers.dto.requests.project_requests import ProjectFilter
-from ..shared import now_epoch_ms
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
 
 
 class ProjectRepository(IProjectRepository):

solace_agent_mesh/gateway/http_sse/repository/project_user_repository.py

@@ -8,7 +8,7 @@ from sqlalchemy.orm import Session as DBSession
 
 from .models import ProjectUserModel
 from .entities.project_user import ProjectUser
-from ..shared import now_epoch_ms
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
 
 
 class ProjectUserRepository:

solace_agent_mesh/gateway/http_sse/repository/session_repository.py

@@ -5,14 +5,13 @@ 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 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
-from .models.chat_task_model import ChatTaskModel
 
 
 class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepository):
@@ -217,10 +216,7 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         project_id: str | None = None
     ) -> list[Session]:
         """
-        Search sessions by name or content.
-        
-        Uses PostgreSQL full-text search when available (for queries >= 3 chars),
-        falls back to ILIKE for SQLite or short queries.
+        Search sessions by name/title only using ILIKE.
         """
         # Base query - only non-deleted sessions for the user
         base_query = db_session.query(SessionModel).filter(
@@ -232,54 +228,9 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         if project_id is not None:
             base_query = base_query.filter(SessionModel.project_id == project_id)
 
-        # Detect database dialect
-        dialect_name = db_session.bind.dialect.name
-        use_fts = dialect_name == 'postgresql' and len(query.strip()) >= 3
-
-        if use_fts:
-            # PostgreSQL full-text search for better performance
-            matching_chat_tasks = (
-                db_session.query(ChatTaskModel.session_id)
-                .filter(
-                    or_(
-                        func.to_tsvector('english', func.coalesce(ChatTaskModel.user_message, ''))
-                            .op('@@')(func.plainto_tsquery('english', query)),
-                        func.to_tsvector('english', ChatTaskModel.message_bubbles)
-                            .op('@@')(func.plainto_tsquery('english', query))
-                    )
-                )
-                .distinct()
-                .subquery()
-            )
-
-            search_query = base_query.filter(
-                or_(
-                    func.to_tsvector('english', func.coalesce(SessionModel.name, ''))
-                        .op('@@')(func.plainto_tsquery('english', query)),
-                    SessionModel.id.in_(matching_chat_tasks)
-                )
-            )
-        else:
-            # ILIKE search for SQLite or short queries
-            search_pattern = f"%{query}%"
-            matching_chat_tasks = (
-                db_session.query(ChatTaskModel.session_id)
-                .filter(
-                    or_(
-                        ChatTaskModel.user_message.ilike(search_pattern),
-                        ChatTaskModel.message_bubbles.ilike(search_pattern)
-                    )
-                )
-                .distinct()
-                .subquery()
-            )
-
-            search_query = base_query.filter(
-                or_(
-                    SessionModel.name.ilike(search_pattern),
-                    SessionModel.id.in_(matching_chat_tasks)
-                )
-            )
+        # 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))
@@ -299,9 +250,7 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         project_id: str | None = None
     ) -> int:
         """
-        Count search results for pagination.
-        
-        Uses same database-agnostic logic as search() method for consistency.
+        Count search results for pagination (title-only search).
         """
         # Base query - only non-deleted sessions for the user
         base_query = db_session.query(SessionModel).filter(
@@ -312,52 +261,8 @@ class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepo
         if project_id is not None:
             base_query = base_query.filter(SessionModel.project_id == project_id)
 
-        dialect_name = db_session.bind.dialect.name
-        use_fts = dialect_name == 'postgresql' and len(query.strip()) >= 3
-
-        if use_fts:
-            # PostgreSQL full-text search
-            matching_chat_tasks = (
-                db_session.query(ChatTaskModel.session_id)
-                .filter(
-                    or_(
-                        func.to_tsvector('english', func.coalesce(ChatTaskModel.user_message, ''))
-                            .op('@@')(func.plainto_tsquery('english', query)),
-                        func.to_tsvector('english', ChatTaskModel.message_bubbles)
-                            .op('@@')(func.plainto_tsquery('english', query))
-                    )
-                )
-                .distinct()
-                .subquery()
-            )
-
-            search_query = base_query.filter(
-                or_(
-                    func.to_tsvector('english', func.coalesce(SessionModel.name, ''))
-                        .op('@@')(func.plainto_tsquery('english', query)),
-                    SessionModel.id.in_(matching_chat_tasks)
-                )
-            )
-        else:
-            # ILIKE search for SQLite or short queries
-            search_pattern = f"%{query}%"
-            matching_chat_tasks = (
-                db_session.query(ChatTaskModel.session_id)
-                .filter(
-                    or_(
-                        ChatTaskModel.user_message.ilike(search_pattern),
-                        ChatTaskModel.message_bubbles.ilike(search_pattern)
-                    )
-                )
-                .distinct()
-                .subquery()
-            )
-
-            search_query = base_query.filter(
-                or_(
-                    SessionModel.name.ilike(search_pattern),
-                    SessionModel.id.in_(matching_chat_tasks)
-                )
-            )
+        # 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.debug("%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(