solace-agent-mesh 1.4.7__py3-none-any.whl → 1.4.8__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/component.py

@@ -1690,23 +1690,29 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                 message_text += part.text
 
                     if message_text and session_id and user_id:
-                        from .dependencies import (
-                            create_session_service_with_transaction,
-                        )
+                        from .dependencies import SessionLocal, get_session_business_service
                         from ...gateway.http_sse.shared.enums import SenderType
 
-                        with create_session_service_with_transaction() as (
-                            session_service,
-                            db,
-                        ):
-                            session_service.add_message_to_session(
-                                session_id=session_id,
-                                user_id=user_id,
-                                message=message_text,
-                                sender_type=SenderType.AGENT,
-                                sender_name=agent_name,
-                                agent_id=agent_name,
-                            )
+                        # For background processing, create simple session wrapper
+                        if SessionLocal:
+                            db = SessionLocal()
+                            try:
+                                session_service = get_session_business_service()
+                                session_service.add_message_to_session(
+                                    db=db,
+                                    session_id=session_id,
+                                    user_id=user_id,
+                                    message=message_text,
+                                    sender_type=SenderType.AGENT,
+                                    sender_name=agent_name,
+                                    agent_id=agent_name,
+                                )
+                                db.commit()
+                            except Exception:
+                                db.rollback()
+                                raise
+                            finally:
+                                db.close()
                         log.info(
                             "%s Final agent response stored in session %s",
                             log_id_prefix,

solace_agent_mesh/gateway/http_sse/dependencies.py

@@ -273,6 +273,54 @@ async def get_user_config(
     )
 
 
+class ValidatedUserConfig:
+    """
+    FastAPI dependency class for validating user scopes and returning user config.
+
+    This class creates a callable dependency that validates a user has the required
+    scopes before allowing access to protected endpoints.
+
+    Args:
+        required_scopes: List of scope strings required for authorization
+
+    Raises:
+        HTTPException: 403 if user lacks required scopes
+
+    Example:
+        @router.get("/artifacts")
+        async def list_artifacts(
+            user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:list"])),
+        ):
+    """
+
+    def __init__(self, required_scopes: list[str]):
+        self.required_scopes = required_scopes
+
+    async def __call__(
+        self,
+        request: Request,
+        config_resolver: ConfigResolver = Depends(get_config_resolver),
+        user_config: dict[str, Any] = Depends(get_user_config),
+    ) -> dict[str, Any]:
+        user_id = user_config.get("user_profile", {}).get("id")
+
+        log.debug(f"[Dependencies] ValidatedUserConfig called for user_id: {user_id} with required scopes: {self.required_scopes}")
+
+        # Validate scopes
+        if not config_resolver.is_feature_enabled(
+                user_config, {"tool_metadata": {"required_scopes": self.required_scopes}}, {}
+        ):
+            log.warning(
+                f"[Dependencies] Authorization denied for user '{user_id}'. Required scopes: {self.required_scopes}"
+            )
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f"Not authorized. Required scopes: {self.required_scopes}"
+            )
+
+        return user_config
+
+
 def get_shared_artifact_service(
     component: "WebUIBackendComponent" = Depends(get_sac_component),
 ) -> BaseArtifactService | None:
@@ -366,98 +414,15 @@ def get_db() -> Generator[Session, None, None]:
 
 
 def get_session_business_service(
-    db: Session = Depends(get_db),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
 ) -> SessionService:
     log.debug("[Dependencies] get_session_business_service called")
 
-    session_repository = SessionRepository(db)
-    message_repository = MessageRepository(db)
-    return SessionService(session_repository, message_repository, component)
-
+    # Note: Session and message repositories will be created per request
+    # when the SessionService methods receive the db parameter
+    return SessionService(component=component)
 
-@contextmanager
-def create_session_service_with_transaction():
-    """Create session data access service with its own transaction for non-HTTP contexts."""
-    if SessionLocal is None:
-        raise RuntimeError("Database not configured")
 
-    db = SessionLocal()
-    try:
-        session_repository = SessionRepository(db)
-        message_repository = MessageRepository(db)
-
-        # Create a simple data access object for transaction contexts
-        # This provides the basic repository operations without business logic
-        class SessionDataAccess:
-            def __init__(self, session_repo, message_repo):
-                self.session_repository = session_repo
-                self.message_repository = message_repo
-
-            def add_message_to_session(
-                self,
-                session_id,
-                user_id,
-                message,
-                sender_type,
-                sender_name,
-                agent_id=None,
-            ):
-                # Simple data access - just save the message
-                from uuid import uuid4
-
-                from .shared.enums import MessageType
-                from .shared import now_epoch_ms
-
-                message_entity = Message(
-                    id=str(uuid4()),
-                    session_id=session_id,
-                    message=message,
-                    sender_type=sender_type,
-                    sender_name=sender_name,
-                    message_type=MessageType.TEXT,
-                    created_time=now_epoch_ms(),
-                )
-                return self.message_repository.save(message_entity)
-
-            def get_session(self, session_id, user_id):
-                # Use the session repository to find the session
-                return self.session_repository.find_user_session(session_id, user_id)
-
-            def create_session(
-                self, user_id, name=None, agent_id=None, session_id=None
-            ):
-                # Create a new session using the session repository
-                from uuid import uuid4
-
-                from .repository.entities import Session
-                from .shared import now_epoch_ms
-
-                if not session_id:
-                    session_id = str(uuid4())
-
-                # Leave name as None/empty - frontend will generate display name if needed
-
-                now_ms = now_epoch_ms()
-                session = Session(
-                    id=session_id,
-                    user_id=user_id,
-                    name=name,
-                    agent_id=agent_id,
-                    created_time=now_ms,
-                    updated_time=now_ms,
-                )
-
-                return self.session_repository.save(session)
-
-        session_service = SessionDataAccess(session_repository, message_repository)
-        yield session_service, db
-        db.commit()
-    except Exception:
-        db.rollback()
-        raise
-    finally:
-        db.close()
 
 
 def get_session_validator(
@@ -470,9 +435,13 @@ def get_session_validator(
 
         def validate_with_database(session_id: str, user_id: str) -> bool:
             try:
-                with create_session_service_with_transaction() as (session_service, db):
-                    session_domain = session_service.get_session(session_id, user_id)
+                db = SessionLocal()
+                try:
+                    session_repository = SessionRepository(db)
+                    session_domain = session_repository.find_user_session(session_id, user_id)
                     return session_domain is not None
+                finally:
+                    db.close()
             except:
                 return False
 
@@ -486,3 +455,30 @@ def get_session_validator(
             return bool(user_id)
 
         return validate_without_database
+
+
+def get_db_optional() -> Generator[Session | None, None, None]:
+    """Optional database dependency that returns None if database is not configured."""
+    if SessionLocal is None:
+        log.debug("[Dependencies] Database not configured, returning None")
+        yield None
+    else:
+        db = SessionLocal()
+        try:
+            yield db
+            db.commit()
+        except Exception:
+            db.rollback()
+            raise
+        finally:
+            db.close()
+
+
+def get_session_business_service_optional(
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+) -> SessionService | None:
+    """Optional session service dependency that returns None if database is not configured."""
+    if SessionLocal is None:
+        log.debug("[Dependencies] Database not configured, returning None for session service")
+        return None
+    return SessionService(component=component)

solace_agent_mesh/gateway/http_sse/main.py

@@ -479,6 +479,12 @@ def _setup_routers() -> None:
     app.include_router(auth.router, prefix=api_prefix, tags=["Auth"])
     log.info("Legacy routers mounted for endpoints not yet migrated")
 
+    # Register shared exception handlers from community repo
+    from .shared.exception_handlers import register_exception_handlers
+    register_exception_handlers(app)
+    log.info("Registered shared exception handlers from community repo")
+
+    # Mount enterprise routers if available
     try:
         from solace_agent_mesh_enterprise.webui_backend.routers import get_enterprise_routers
 
@@ -494,9 +500,9 @@ def _setup_routers() -> None:
     except ImportError:
         log.debug("No enterprise package detected - skipping enterprise routers")
     except ModuleNotFoundError:
-        log.debug("Enterprise router module not found - skipping enterprise routers")
+        log.debug("Enterprise module not found - skipping enterprise routers and exception handlers")
     except Exception as e:
-        log.warning("Failed to load enterprise routers: %s", e)
+        log.warning("Failed to load enterprise routers and exception handlers: %s", e)
 
 
 def _setup_static_files() -> None:

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

@@ -2,7 +2,7 @@
 Message domain entity.
 """
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from ...shared.enums import MessageType, SenderType
 from ...shared.types import MessageId, SessionId
@@ -11,6 +11,8 @@ from ...shared.types import MessageId, SessionId
 class Message(BaseModel):
     """Message domain entity with business logic."""
 
+    model_config = ConfigDict(from_attributes=True)
+
     id: MessageId
     session_id: SessionId
     message: str

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

@@ -2,7 +2,7 @@
 Session domain entity.
 """
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from ...shared import now_epoch_ms
 from ...shared.types import AgentId, SessionId, UserId
@@ -11,6 +11,8 @@ from ...shared.types import AgentId, SessionId, UserId
 class Session(BaseModel):
     """Session domain entity with business logic."""
 
+    model_config = ConfigDict(from_attributes=True)
+
     id: SessionId
     user_id: UserId
     name: str | None = None

solace_agent_mesh/gateway/http_sse/repository/interfaces.py

@@ -18,6 +18,11 @@ class ISessionRepository(ABC):
         """Find all sessions for a specific user."""
         pass
 
+    @abstractmethod
+    def count_by_user(self, user_id: UserId) -> int:
+        """Count total sessions for a specific user."""
+        pass
+
     @abstractmethod
     def find_user_session(
         self, session_id: SessionId, user_id: UserId

solace_agent_mesh/gateway/http_sse/repository/message_repository.py

@@ -4,19 +4,26 @@ Message repository implementation using SQLAlchemy.
 
 from sqlalchemy.orm import Session as DBSession
 
+from ..shared.base_repository import PaginatedRepository
 from ..shared.enums import MessageType, SenderType
 from ..shared.types import PaginationInfo, SessionId
 from .entities import Message
 from .interfaces import IMessageRepository
-from .models import MessageModel
+from .models import MessageModel, CreateMessageModel, UpdateMessageModel
 
 
-class MessageRepository(IMessageRepository):
-    """SQLAlchemy implementation of message repository."""
+class MessageRepository(PaginatedRepository[MessageModel, Message], IMessageRepository):
+    """SQLAlchemy implementation of message repository using BaseRepository."""
 
     def __init__(self, db: DBSession):
+        super().__init__(MessageModel, Message)
         self.db = db
 
+    @property
+    def entity_name(self) -> str:
+        """Return the entity name for error messages."""
+        return "message"
+
     def find_by_session(
         self, session_id: SessionId, pagination: PaginationInfo | None = None
     ) -> list[Message]:
@@ -24,28 +31,28 @@ class MessageRepository(IMessageRepository):
         query = self.db.query(MessageModel).filter(
             MessageModel.session_id == session_id
         )
+        query = query.order_by(MessageModel.created_time.asc())
 
         if pagination:
             offset = (pagination.page - 1) * pagination.page_size
             query = query.offset(offset).limit(pagination.page_size)
 
-        models = query.order_by(MessageModel.created_time.asc()).all()
-        return [self._model_to_entity(model) for model in models]
+        models = query.all()
+        return [self._convert_model_to_entity(model) for model in models]
 
     def save(self, message: Message) -> Message:
         """Save or update a message."""
-        model = (
-            self.db.query(MessageModel).filter(MessageModel.id == message.id).first()
-        )
+        existing_model = self.db.query(MessageModel).filter(MessageModel.id == message.id).first()
 
-        if model:
-            # Update existing
-            model.message = message.message
-            model.sender_type = message.sender_type.value
-            model.sender_name = message.sender_name
+        if existing_model:
+            update_model = UpdateMessageModel(
+                message=message.message,
+                sender_type=message.sender_type.value,
+                sender_name=message.sender_name,
+            )
+            return self.update(self.db, message.id, update_model.model_dump())
         else:
-            # Create new
-            model = MessageModel(
+            create_model = CreateMessageModel(
                 id=message.id,
                 session_id=message.session_id,
                 message=message.message,
@@ -53,11 +60,7 @@ class MessageRepository(IMessageRepository):
                 sender_name=message.sender_name,
                 created_time=message.created_time,
             )
-            self.db.add(model)
-
-        self.db.commit()
-        self.db.refresh(model)
-        return self._model_to_entity(model)
+            return self.create(self.db, create_model.model_dump())
 
     def delete_by_session(self, session_id: SessionId) -> bool:
         """Delete all messages in a session."""
@@ -66,11 +69,10 @@ class MessageRepository(IMessageRepository):
             .filter(MessageModel.session_id == session_id)
             .delete()
         )
-        self.db.commit()
         return result > 0
 
-    def _model_to_entity(self, model: MessageModel) -> Message:
-        """Convert SQLAlchemy model to domain entity."""
+    def _convert_model_to_entity(self, model: MessageModel) -> Message:
+        """Convert SQLAlchemy model to domain entity with enum handling."""
         return Message(
             id=model.id,
             session_id=model.session_id,

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

@@ -1,9 +1,17 @@
 """
-SQLAlchemy models for database persistence.
+SQLAlchemy models and Pydantic models for database persistence.
 """
 
 from .base import Base
-from .message_model import MessageModel
-from .session_model import SessionModel
+from .message_model import MessageModel, CreateMessageModel, UpdateMessageModel
+from .session_model import SessionModel, CreateSessionModel, UpdateSessionModel
 
-__all__ = ["Base", "MessageModel", "SessionModel"]
+__all__ = [
+    "Base",
+    "MessageModel",
+    "SessionModel",
+    "CreateMessageModel",
+    "UpdateMessageModel",
+    "CreateSessionModel",
+    "UpdateSessionModel",
+]

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

@@ -1,7 +1,8 @@
 """
-Message SQLAlchemy model.
+Message SQLAlchemy model and Pydantic models for strongly-typed operations.
 """
 
+from pydantic import BaseModel
 from sqlalchemy import BigInteger, Column, ForeignKey, String, Text
 from sqlalchemy.orm import relationship
 
@@ -25,3 +26,20 @@ class MessageModel(Base):
 
     # Relationship to session
     session = relationship("SessionModel", back_populates="messages")
+
+
+class CreateMessageModel(BaseModel):
+    """Pydantic model for creating a message."""
+    id: str
+    session_id: str
+    message: str
+    sender_type: str
+    sender_name: str
+    created_time: int
+
+
+class UpdateMessageModel(BaseModel):
+    """Pydantic model for updating a message."""
+    message: str
+    sender_type: str
+    sender_name: str

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

@@ -1,7 +1,8 @@
 """
-Session SQLAlchemy model.
+Session SQLAlchemy model and Pydantic models for strongly-typed operations.
 """
 
+from pydantic import BaseModel
 from sqlalchemy import BigInteger, Column, String
 from sqlalchemy.orm import relationship
 
@@ -27,3 +28,20 @@ class SessionModel(Base):
     messages = relationship(
         "MessageModel", back_populates="session", cascade="all, delete-orphan"
     )
+
+
+class CreateSessionModel(BaseModel):
+    """Pydantic model for creating a session."""
+    id: str
+    name: str | None
+    user_id: str
+    agent_id: str | None
+    created_time: int
+    updated_time: int
+
+
+class UpdateSessionModel(BaseModel):
+    """Pydantic model for updating a session."""
+    name: str | None = None
+    agent_id: str | None = None
+    updated_time: int

solace_agent_mesh/gateway/http_sse/repository/session_repository.py

@@ -4,30 +4,47 @@ Session repository implementation using SQLAlchemy.
 
 from sqlalchemy.orm import Session as DBSession
 
+from ..shared.base_repository import PaginatedRepository
 from ..shared.types import PaginationInfo, SessionId, UserId
 from .entities import Message, Session
 from .interfaces import ISessionRepository
-from .models import MessageModel, SessionModel
+from .models import (
+    MessageModel,
+    SessionModel,
+    CreateSessionModel,
+    UpdateSessionModel,
+)
 
 
-class SessionRepository(ISessionRepository):
-    """SQLAlchemy implementation of session repository."""
+class SessionRepository(PaginatedRepository[SessionModel, Session], ISessionRepository):
+    """SQLAlchemy implementation of session repository using BaseRepository."""
 
     def __init__(self, db: DBSession):
+        super().__init__(SessionModel, Session)
         self.db = db
 
+    @property
+    def entity_name(self) -> str:
+        """Return the entity name for error messages."""
+        return "session"
+
     def find_by_user(
         self, user_id: UserId, pagination: PaginationInfo | None = None
     ) -> list[Session]:
         """Find all sessions for a specific user."""
         query = self.db.query(SessionModel).filter(SessionModel.user_id == user_id)
+        query = query.order_by(SessionModel.updated_time.desc())
 
         if pagination:
             offset = (pagination.page - 1) * pagination.page_size
             query = query.offset(offset).limit(pagination.page_size)
 
-        models = query.order_by(SessionModel.updated_time.desc()).all()
-        return [self._model_to_entity(model) for model in models]
+        models = query.all()
+        return [Session.model_validate(model) for model in models]
+
+    def count_by_user(self, user_id: UserId) -> int:
+        """Count total sessions for a specific user."""
+        return self.db.query(SessionModel).filter(SessionModel.user_id == user_id).count()
 
     def find_user_session(
         self, session_id: SessionId, user_id: UserId
@@ -41,22 +58,21 @@ class SessionRepository(ISessionRepository):
             )
             .first()
         )
-        return self._model_to_entity(model) if model else None
+        return Session.model_validate(model) if model else None
 
     def save(self, session: Session) -> Session:
         """Save or update a session."""
-        model = (
-            self.db.query(SessionModel).filter(SessionModel.id == session.id).first()
-        )
+        existing_model = self.db.query(SessionModel).filter(SessionModel.id == session.id).first()
 
-        if model:
-            # Update existing
-            model.name = session.name
-            model.agent_id = session.agent_id
-            model.updated_time = session.updated_time
+        if existing_model:
+            update_model = UpdateSessionModel(
+                name=session.name,
+                agent_id=session.agent_id,
+                updated_time=session.updated_time,
+            )
+            return self.update(self.db, session.id, update_model.model_dump(exclude_none=True))
         else:
-            # Create new
-            model = SessionModel(
+            create_model = CreateSessionModel(
                 id=session.id,
                 name=session.name,
                 user_id=session.user_id,
@@ -64,24 +80,22 @@ class SessionRepository(ISessionRepository):
                 created_time=session.created_time,
                 updated_time=session.updated_time,
             )
-            self.db.add(model)
-
-        self.db.commit()
-        self.db.refresh(model)
-        return self._model_to_entity(model)
+            return self.create(self.db, create_model.model_dump())
 
     def delete(self, session_id: SessionId, user_id: UserId) -> bool:
         """Delete a session belonging to a user."""
-        result = (
-            self.db.query(SessionModel)
-            .filter(
-                SessionModel.id == session_id,
-                SessionModel.user_id == user_id,
-            )
-            .delete()
-        )
-        self.db.commit()
-        return result > 0
+        # Check if session belongs to user first
+        session_model = self.db.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(self.db, session_id)
+        return True
 
     def find_user_session_with_messages(
         self,
@@ -112,21 +126,11 @@ class SessionRepository(ISessionRepository):
 
         message_models = message_query.order_by(MessageModel.created_time.asc()).all()
 
-        session = self._model_to_entity(session_model)
+        session = Session.model_validate(session_model)
         messages = [self._message_model_to_entity(model) for model in message_models]
 
         return session, messages
 
-    def _model_to_entity(self, model: SessionModel) -> Session:
-        """Convert SQLAlchemy model to domain entity."""
-        return Session(
-            id=model.id,
-            user_id=model.user_id,
-            name=model.name,
-            agent_id=model.agent_id,
-            created_time=model.created_time,
-            updated_time=model.updated_time,
-        )
 
     def _message_model_to_entity(self, model: MessageModel) -> Message:
         """Convert SQLAlchemy message model to domain entity."""