solace-agent-mesh 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

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

@@ -0,0 +1,27 @@
+"""
+Message SQLAlchemy model.
+"""
+
+from sqlalchemy import Column, DateTime, ForeignKey, String, Text
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+
+from .base import Base
+
+
+class MessageModel(Base):
+    """SQLAlchemy model for messages."""
+    
+    __tablename__ = "chat_messages"
+    
+    id = Column(String, primary_key=True)
+    session_id = Column(
+        String, ForeignKey("sessions.id", ondelete="CASCADE"), nullable=False
+    )
+    message = Column(Text, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    sender_type = Column(String(50))
+    sender_name = Column(String(255))
+    
+    # Relationship to session
+    session = relationship("SessionModel", back_populates="messages")

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

@@ -0,0 +1,27 @@
+"""
+Session SQLAlchemy model.
+"""
+
+from sqlalchemy import Column, DateTime, String
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+
+from .base import Base
+
+
+class SessionModel(Base):
+    """SQLAlchemy model for sessions."""
+    
+    __tablename__ = "sessions"
+    
+    id = Column(String, primary_key=True)
+    name = Column(String, nullable=True)
+    user_id = Column(String, nullable=False)
+    agent_id = Column(String, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    
+    # Relationship to messages
+    messages = relationship(
+        "MessageModel", back_populates="session", cascade="all, delete-orphan"
+    )

solace_agent_mesh/gateway/http_sse/repository/session_repository.py

@@ -0,0 +1,139 @@
+"""
+Session repository implementation using SQLAlchemy.
+"""
+
+from sqlalchemy.orm import Session as DBSession
+
+from ..shared.types import PaginationInfo, SessionId, UserId
+from .entities import Message, Session
+from .interfaces import ISessionRepository
+from .models import MessageModel, SessionModel
+
+
+class SessionRepository(ISessionRepository):
+    """SQLAlchemy implementation of session repository."""
+    
+    def __init__(self, db: DBSession):
+        self.db = db
+
+    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)
+
+        if pagination:
+            offset = (pagination.page - 1) * pagination.page_size
+            query = query.offset(offset).limit(pagination.page_size)
+
+        models = query.order_by(SessionModel.updated_at.desc()).all()
+        return [self._model_to_entity(model) for model in models]
+
+    def find_user_session(
+        self, session_id: SessionId, user_id: UserId
+    ) -> Session | None:
+        """Find a specific session belonging to a user."""
+        model = (
+            self.db.query(SessionModel)
+            .filter(
+                SessionModel.id == session_id,
+                SessionModel.user_id == user_id,
+            )
+            .first()
+        )
+        return self._model_to_entity(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()
+
+        if model:
+            # Update existing
+            model.name = session.name
+            model.agent_id = session.agent_id
+            model.updated_at = session.updated_at
+        else:
+            # Create new
+            model = SessionModel(
+                id=session.id,
+                name=session.name,
+                user_id=session.user_id,
+                agent_id=session.agent_id,
+                created_at=session.created_at,
+                updated_at=session.updated_at,
+            )
+            self.db.add(model)
+
+        self.db.commit()
+        self.db.refresh(model)
+        return self._model_to_entity(model)
+
+    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
+
+    def find_user_session_with_messages(
+        self, session_id: SessionId, user_id: UserId, pagination: PaginationInfo | None = None
+    ) -> tuple[Session, list[Message]] | None:
+        """Find a session with its messages."""
+        session_model = (
+            self.db.query(SessionModel)
+            .filter(
+                SessionModel.id == session_id,
+                SessionModel.user_id == user_id,
+            )
+            .first()
+        )
+
+        if not session_model:
+            return None
+
+        message_query = self.db.query(MessageModel).filter(
+            MessageModel.session_id == session_id
+        )
+
+        if pagination:
+            offset = (pagination.page - 1) * pagination.page_size
+            message_query = message_query.offset(offset).limit(pagination.page_size)
+
+        message_models = message_query.order_by(MessageModel.created_at.asc()).all()
+
+        session = self._model_to_entity(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_at=model.created_at,
+            updated_at=model.updated_at,
+            last_activity=model.updated_at,
+        )
+
+    def _message_model_to_entity(self, model: MessageModel) -> Message:
+        """Convert SQLAlchemy message model to domain entity."""
+        from ..shared.enums import MessageType, SenderType
+        
+        return Message(
+            id=model.id,
+            session_id=model.session_id,
+            message=model.message,
+            sender_type=SenderType(model.sender_type),
+            sender_name=model.sender_name,
+            message_type=MessageType.TEXT,  # Default for now
+            created_at=model.created_at,
+        )

solace_agent_mesh/gateway/http_sse/routers/config.py

@@ -43,6 +43,7 @@ async def get_app_config(
                 "frontend_collect_feedback", False
             ),
             "frontend_bot_name": component.get_config("frontend_bot_name", "A2A Agent"),
+            "frontend_feature_enablement": component.get_config("frontend_feature_enablement", {}),
             "persistence_enabled": api_config.get("persistence_enabled", False),
         }
         log.info("%sReturning frontend configuration.", log_prefix)

solace_agent_mesh/gateway/http_sse/routers/dto/requests/__init__.py

@@ -0,0 +1,20 @@
+"""
+Request DTOs for API endpoints.
+"""
+
+from .session_requests import (
+    GetSessionsRequest,
+    GetSessionRequest,
+    GetSessionHistoryRequest,
+    UpdateSessionRequest,
+    DeleteSessionRequest,
+)
+
+__all__ = [
+    # Session requests
+    "GetSessionsRequest",
+    "GetSessionRequest", 
+    "GetSessionHistoryRequest",
+    "UpdateSessionRequest",
+    "DeleteSessionRequest",
+]

solace_agent_mesh/gateway/http_sse/{api → routers}/dto/requests/session_requests.py

@@ -39,11 +39,4 @@ class UpdateSessionRequest(BaseModel):
 class DeleteSessionRequest(BaseModel):
     """Request DTO for deleting a session."""
     session_id: SessionId
-    user_id: UserId
-
-
-class CreateSessionRequest(BaseModel):
-    """Request DTO for creating a new session."""
-    user_id: UserId
-    name: Optional[str] = Field(None, max_length=255, description="Session name")
-    agent_id: Optional[str] = Field(None, description="Associated agent ID")
+    user_id: UserId

solace_agent_mesh/gateway/http_sse/routers/dto/responses/__init__.py

@@ -0,0 +1,16 @@
+"""
+Response DTOs for API endpoints.
+"""
+
+from .session_responses import (
+    MessageResponse,
+    SessionResponse,
+    SessionListResponse,
+)
+
+__all__ = [
+    # Session responses
+    "MessageResponse",
+    "SessionResponse",
+    "SessionListResponse",
+]

solace_agent_mesh/gateway/http_sse/{api → routers}/dto/responses/session_responses.py

@@ -4,10 +4,10 @@ Session-related response DTOs.
 
 from typing import List, Optional
 from datetime import datetime
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
-from ....shared.types import SessionId, UserId, MessageId, PaginationInfo, Timestamp
-from ....shared.enums import SessionStatus, SenderType, MessageType
+from ....shared.types import SessionId, UserId, MessageId, PaginationInfo
+from ....shared.enums import SenderType, MessageType
 
 
 class MessageResponse(BaseModel):
@@ -29,7 +29,6 @@ class SessionResponse(BaseModel):
     user_id: UserId
     name: Optional[str] = None
     agent_id: Optional[str] = None
-    status: SessionStatus = SessionStatus.ACTIVE
     created_at: datetime
     updated_at: Optional[datetime] = None
     last_activity: Optional[datetime] = None
@@ -40,29 +39,3 @@ class SessionListResponse(BaseModel):
     sessions: List[SessionResponse]
     pagination: Optional[PaginationInfo] = None
     total_count: int
-
-
-class SessionHistoryResponse(BaseModel):
-    """Response DTO for session message history."""
-    session_id: SessionId
-    messages: List[MessageResponse]
-    pagination: Optional[PaginationInfo] = None
-    total_count: int
-
-
-class SessionCreatedResponse(BaseModel):
-    """Response DTO for session creation."""
-    session: SessionResponse
-    message: str = "Session created successfully"
-
-
-class SessionUpdatedResponse(BaseModel):
-    """Response DTO for session update."""
-    session: SessionResponse
-    message: str = "Session updated successfully"
-
-
-class SessionDeletedResponse(BaseModel):
-    """Response DTO for session deletion."""
-    session_id: SessionId
-    message: str = "Session deleted successfully"

solace_agent_mesh/gateway/http_sse/{api/controllers/session_controller.py → routers/sessions.py}

@@ -1,22 +1,19 @@
-from fastapi import APIRouter, Body, Depends, HTTPException, status
+from fastapi import APIRouter, Body, Depends, HTTPException, status, BackgroundTasks
 from solace_ai_connector.common.log import log
 
-from ...application.services.session_service import SessionService
-from ...dependencies import (
-    PublishFunc,
-    get_namespace,
-    get_publish_a2a_func,
-    get_session_service,
+from ..services.session_service import SessionService
+from ..dependencies import (
+    get_session_business_service,
 )
-from ...shared.auth_utils import get_current_user
-from ..dto.requests.session_requests import (
+from ..shared.auth_utils import get_current_user
+from .dto.requests.session_requests import (
     DeleteSessionRequest,
     GetSessionHistoryRequest,
     GetSessionRequest,
     GetSessionsRequest,
     UpdateSessionRequest,
 )
-from ..dto.responses.session_responses import (
+from .dto.responses.session_responses import (
     MessageResponse,
     SessionListResponse,
     SessionResponse,
@@ -28,7 +25,7 @@ router = APIRouter()
 @router.get("/sessions", response_model=SessionListResponse)
 async def get_all_sessions(
     user: dict = Depends(get_current_user),
-    session_service: SessionService = Depends(get_session_service),
+    session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
     log.info("Fetching sessions for user_id: %s", user_id)
@@ -47,7 +44,6 @@ async def get_all_sessions(
                 user_id=domain.user_id,
                 name=domain.name,
                 agent_id=domain.agent_id,
-                status=domain.status,
                 created_at=domain.created_at,
                 updated_at=domain.updated_at,
                 last_activity=domain.last_activity,
@@ -72,7 +68,7 @@ async def get_all_sessions(
 async def get_session(
     session_id: str,
     user: dict = Depends(get_current_user),
-    session_service: SessionService = Depends(get_session_service),
+    session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
     log.info("User %s attempting to fetch session_id: %s", user_id, session_id)
@@ -89,7 +85,7 @@ async def get_session(
 
         request_dto = GetSessionRequest(session_id=session_id, user_id=user_id)
 
-        session_domain = session_service.get_session(
+        session_domain = session_service.get_session_details(
             session_id=request_dto.session_id, user_id=request_dto.user_id
         )
 
@@ -105,7 +101,6 @@ async def get_session(
             user_id=session_domain.user_id,
             name=session_domain.name,
             agent_id=session_domain.agent_id,
-            status=session_domain.status,
             created_at=session_domain.created_at,
             updated_at=session_domain.updated_at,
             last_activity=session_domain.last_activity,
@@ -130,7 +125,7 @@ async def get_session(
 async def get_session_history(
     session_id: str,
     user: dict = Depends(get_current_user),
-    session_service: SessionService = Depends(get_session_service),
+    session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
     log.info(
@@ -202,7 +197,7 @@ async def update_session_name(
     session_id: str,
     name: str = Body(..., embed=True),
     user: dict = Depends(get_current_user),
-    session_service: SessionService = Depends(get_session_service),
+    session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
     log.info("User %s attempting to update session %s", user_id, session_id)
@@ -239,7 +234,6 @@ async def update_session_name(
             user_id=updated_domain.user_id,
             name=updated_domain.name,
             agent_id=updated_domain.agent_id,
-            status=updated_domain.status,
             created_at=updated_domain.created_at,
             updated_at=updated_domain.updated_at,
             last_activity=updated_domain.last_activity,
@@ -269,36 +263,14 @@ async def update_session_name(
 async def delete_session(
     session_id: str,
     user: dict = Depends(get_current_user),
-    session_service: SessionService = Depends(get_session_service),
-    publish_func: PublishFunc = Depends(get_publish_a2a_func),
-    namespace: str = Depends(get_namespace),
+    session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
     log.info("User %s attempting to delete session %s", user_id, session_id)
 
     try:
-        if (
-            not session_id
-            or session_id.strip() == ""
-            or session_id in ["null", "undefined"]
-        ):
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
-            )
-
-        request_dto = DeleteSessionRequest(session_id=session_id, user_id=user_id)
-
-        # Get session details before deletion to find the agent_id
-        session = session_service.get_session(session_id=session_id, user_id=user_id)
-        if not session:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
-            )
-
-        agent_id = session.agent_id
-
-        deleted = session_service.delete_session(
-            session_id=request_dto.session_id, user_id=request_dto.user_id
+        deleted = session_service.delete_session_with_notifications(
+            session_id=session_id, user_id=user_id
         )
 
         if not deleted:
@@ -308,40 +280,11 @@ async def delete_session(
 
         log.info("Session %s deleted successfully", session_id)
 
-        if agent_id:
-            try:
-                from solace_agent_mesh.common.a2a.protocol import (
-                    get_agent_request_topic,
-                )
-
-                control_message = {
-                    "control": {
-                        "action": "delete_session",
-                        "session_id": session_id,
-                        "user_id": user_id,
-                    }
-                }
-
-                target_topic = get_agent_request_topic(namespace, agent_id)
-
-                log.info(
-                    "Sending session deletion notification to agent %s for session %s",
-                    agent_id,
-                    session_id,
-                )
-
-                publish_func(target_topic, control_message, None)
-
-            except Exception as e:
-                log.warning(
-                    "Failed to notify agent %s about session %s deletion: %s",
-                    agent_id,
-                    session_id,
-                    e,
-                )
-
-    except HTTPException:
-        raise
+    except ValueError as e:
+        log.warning("Validation error deleting session %s: %s", session_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        )
     except Exception as e:
         log.error(
             "Error deleting session %s for user %s: %s",

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -105,60 +105,53 @@ async def _submit_task(
 
         # Store message in persistence layer if available
         user_id = user_identity.get("id")
-        if is_streaming and hasattr(component, "persistence_service") and component.persistence_service:
+        from ....gateway.http_sse.dependencies import SessionLocal
+        if is_streaming and SessionLocal is not None:
             try:
-                from ....gateway.http_sse.dependencies import get_session_service
+                from ....gateway.http_sse.dependencies import create_session_service_with_transaction
                 from ....gateway.http_sse.shared.enums import SenderType
                 
-                session_service = get_session_service(component)
-                
-                # First ensure session exists in database - create it with the SessionManager's ID
-                # Handle race condition where multiple requests might try to create the same session
-                existing_session = session_service.get_session(session_id=session_id, user_id=user_id)
-                if not existing_session:
-                    log.info("%sCreating new session in database: %s", log_prefix, session_id)
-                    try:
-                        session_service.create_session(
-                            user_id=user_id,
-                            agent_id=agent_name,
-                            name=None,  # Will be auto-generated if needed
-                            session_id=session_id  # Use the SessionManager's session ID
-                        )
-                    except Exception as create_error:
-                        # Another request may have created the session concurrently
-                        log.warning("%sSession creation failed, checking if session exists: %s", log_prefix, create_error)
-                        existing_session = session_service.get_session(session_id=session_id, user_id=user_id)
-                        if not existing_session:
-                            # If session still doesn't exist, re-raise the original error
-                            raise create_error
-                        log.info("%sSession was created by another request: %s", log_prefix, session_id)
-                
-                # Extract text content from the message for storage
-                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
-                
-                # Now store the message in the existing session
-                message_domain = session_service.add_message_to_session(
-                    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,
-                )
-                
-                if message_domain:
-                    log.info("%sMessage stored in session %s", log_prefix, session_id)
-                else:
-                    log.warning("%sFailed to store message in session %s", log_prefix, session_id)
+                with create_session_service_with_transaction() as (session_service, db):
+                    existing_session = session_service.get_session(session_id=session_id, user_id=user_id)
+                    if not existing_session:
+                        log.info("%sCreating new session in database: %s", log_prefix, session_id)
+                        try:
+                            session_service.create_session(
+                                user_id=user_id,
+                                agent_id=agent_name,
+                                name=None,
+                                session_id=session_id
+                            )
+                        except Exception as create_error:
+                            log.warning("%sSession creation failed, checking if session exists: %s", log_prefix, create_error)
+                            existing_session = session_service.get_session(session_id=session_id, user_id=user_id)
+                            if not existing_session:
+                                raise create_error
+                            log.info("%sSession was created by another request: %s", log_prefix, session_id)
+                    
+                    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
+                    
+                    message_domain = session_service.add_message_to_session(
+                        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,
+                    )
+                    
+                    if message_domain:
+                        log.info("%sMessage stored in session %s", log_prefix, session_id)
+                    else:
+                        log.warning("%sFailed to store message in session %s", log_prefix, session_id)
             except Exception as e:
                 log.error("%sFailed to store message in session service: %s", log_prefix, e)
-                # Don't fail the request, just log the error
         else:
             log.debug("%sNo persistence available or non-streaming - skipping message storage", log_prefix)
 

solace_agent_mesh/gateway/http_sse/{api/controllers/user_controller.py → routers/users.py}

@@ -8,7 +8,7 @@ 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
+from ..shared.auth_utils import get_current_user
 
 router = APIRouter()