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

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -1,94 +1,51 @@
-from fastapi import APIRouter, Body, Depends, HTTPException, status
-from fastapi import Request as FastAPIRequest
+from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
 from solace_ai_connector.common.log import log
+from sqlalchemy.orm import Session
 
-from a2a.types import JSONRPCSuccessResponse
-from ..dependencies import get_session_business_service, get_session_manager
+from ..dependencies import get_session_business_service, get_db
 from ..services.session_service import SessionService
-from ..session_manager import SessionManager
 from ..shared.auth_utils import get_current_user
+from ..shared.pagination import DataResponse, PaginatedResponse, PaginationParams
+from ..shared.response_utils import create_data_response
 from .dto.requests.session_requests import (
     GetSessionHistoryRequest,
     GetSessionRequest,
-    GetSessionsRequest,
     UpdateSessionRequest,
 )
-from .dto.responses.session_responses import (
-    MessageResponse,
-    SessionListResponse,
-    SessionResponse,
-)
-from ....common.a2a import create_generic_success_response
+from .dto.responses.session_responses import MessageResponse, SessionResponse
 
 router = APIRouter()
 
 
-@router.post("/sessions/new", response_model=JSONRPCSuccessResponse)
-async def create_new_session(
-    request: FastAPIRequest,
-    user: dict = Depends(get_current_user),
-    session_manager: SessionManager = Depends(get_session_manager),
-    session_service: SessionService = Depends(get_session_business_service),
-):
-    """Creates a new session on-demand and returns its ID."""
-    user_id = user.get("id")
-    log.info("User %s requesting new session", user_id)
-    try:
-        new_session_id = session_manager.create_new_session_id(request)
-        log.info("Created new session ID: %s for user %s", new_session_id, user_id)
-
-        # Attempt to create the session record in the DB.
-        # The service will handle the check for whether persistence is enabled.
-        session_service.create_session(
-            user_id=user_id,
-            agent_id=None,  # Agent is not known at this point
-            name=None,
-            session_id=new_session_id,
-        )
-
-        return create_generic_success_response(
-            result={"id": new_session_id}, request_id=None
-        )
-    except Exception as e:
-        log.error("Error creating new session for user %s: %s", user_id, e)
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to create a new session",
-        )
-
 
-@router.get("/sessions", response_model=SessionListResponse)
+@router.get("/sessions", response_model=PaginatedResponse[SessionResponse])
 async def get_all_sessions(
+    page_number: int = Query(default=1, ge=1, alias="pageNumber"),
+    page_size: int = Query(default=20, ge=1, le=100, alias="pageSize"),
+    db: Session = Depends(get_db),
     user: dict = Depends(get_current_user),
     session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
-    log.info("Fetching sessions for user_id: %s", user_id)
+    log.info(f"User '{user_id}' is listing sessions with pagination (page={page_number}, size={page_size})")
 
     try:
-        request_dto = GetSessionsRequest(user_id=user_id)
-
-        session_domains = session_service.get_user_sessions(
-            user_id=request_dto.user_id, pagination=request_dto.pagination
-        )
+        pagination = PaginationParams(page_number=page_number, page_size=page_size)
+        paginated_response = session_service.get_user_sessions(db, user_id, pagination)
 
         session_responses = []
-        for domain in session_domains:
+        for session_domain in paginated_response.data:
             session_response = SessionResponse(
-                id=domain.id,
-                user_id=domain.user_id,
-                name=domain.name,
-                agent_id=domain.agent_id,
-                created_time=domain.created_time,
-                updated_time=domain.updated_time,
+                id=session_domain.id,
+                user_id=session_domain.user_id,
+                name=session_domain.name,
+                agent_id=session_domain.agent_id,
+                created_time=session_domain.created_time,
+                updated_time=session_domain.updated_time,
             )
             session_responses.append(session_response)
 
-        return SessionListResponse(
-            sessions=session_responses,
-            total_count=len(session_responses),
-            pagination=request_dto.pagination,
-        )
+        return PaginatedResponse(data=session_responses, meta=paginated_response.meta)
 
     except Exception as e:
         log.error("Error fetching sessions for user %s: %s", user_id, e)
@@ -98,9 +55,10 @@ async def get_all_sessions(
         )
 
 
-@router.get("/sessions/{session_id}", response_model=SessionResponse)
+@router.get("/sessions/{session_id}", response_model=DataResponse[SessionResponse])
 async def get_session(
     session_id: str,
+    db: Session = Depends(get_db),
     user: dict = Depends(get_current_user),
     session_service: SessionService = Depends(get_session_business_service),
 ):
@@ -120,7 +78,7 @@ async def get_session(
         request_dto = GetSessionRequest(session_id=session_id, user_id=user_id)
 
         session_domain = session_service.get_session_details(
-            session_id=request_dto.session_id, user_id=request_dto.user_id
+            db=db, session_id=request_dto.session_id, user_id=request_dto.user_id
         )
 
         if not session_domain:
@@ -130,7 +88,7 @@ async def get_session(
 
         log.info("User %s authorized. Fetching session_id: %s", user_id, session_id)
 
-        return SessionResponse(
+        session_response = SessionResponse(
             id=session_domain.id,
             user_id=session_domain.user_id,
             name=session_domain.name,
@@ -139,6 +97,8 @@ async def get_session(
             updated_time=session_domain.updated_time,
         )
 
+        return create_data_response(session_response)
+
     except HTTPException:
         raise
     except Exception as e:
@@ -157,6 +117,7 @@ async def get_session(
 @router.get("/sessions/{session_id}/messages")
 async def get_session_history(
     session_id: str,
+    db: Session = Depends(get_db),
     user: dict = Depends(get_current_user),
     session_service: SessionService = Depends(get_session_business_service),
 ):
@@ -178,6 +139,7 @@ async def get_session_history(
         request_dto = GetSessionHistoryRequest(session_id=session_id, user_id=user_id)
 
         history_domain = session_service.get_session_history(
+            db=db,
             session_id=request_dto.session_id,
             user_id=request_dto.user_id,
             pagination=request_dto.pagination,
@@ -228,6 +190,7 @@ async def get_session_history(
 async def update_session_name(
     session_id: str,
     name: str = Body(..., embed=True),
+    db: Session = Depends(get_db),
     user: dict = Depends(get_current_user),
     session_service: SessionService = Depends(get_session_business_service),
 ):
@@ -249,6 +212,7 @@ async def update_session_name(
         )
 
         updated_domain = session_service.update_session_name(
+            db=db,
             session_id=request_dto.session_id,
             user_id=request_dto.user_id,
             name=request_dto.name,
@@ -293,6 +257,7 @@ async def update_session_name(
 @router.delete("/sessions/{session_id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_session(
     session_id: str,
+    db: Session = Depends(get_db),
     user: dict = Depends(get_current_user),
     session_service: SessionService = Depends(get_session_business_service),
 ):
@@ -301,7 +266,7 @@ async def delete_session(
 
     try:
         deleted = session_service.delete_session_with_notifications(
-            session_id=session_id, user_id=user_id
+            db=db, session_id=session_id, user_id=user_id
         )
 
         if not deleted:

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -15,6 +15,7 @@ from solace_ai_connector.common.log import log
 
 from ....gateway.http_sse.session_manager import SessionManager
 from ....gateway.http_sse.services.task_service import TaskService
+from ....gateway.http_sse.services.session_service import SessionService
 
 from a2a.types import (
     CancelTaskRequest,
@@ -29,6 +30,7 @@ from ....gateway.http_sse.dependencies import (
     get_session_manager,
     get_sac_component,
     get_task_service,
+    get_session_business_service,
 )
 
 from typing import TYPE_CHECKING
@@ -45,6 +47,7 @@ async def _submit_task(
     session_manager: SessionManager,
     component: "WebUIBackendComponent",
     is_streaming: bool,
+    session_service: SessionService | None = None,
 ):
     """Helper to submit a task, handling both streaming and non-streaming cases."""
     log_prefix = f"[POST /api/v1/message:{'stream' if is_streaming else 'send'}] "
@@ -77,7 +80,7 @@ async def _submit_task(
 
         client_id = session_manager.get_a2a_client_id(request)
 
-        # Use session ID from frontend request (contextId) instead of cookie-based session
+        # Use session ID from frontend request (contextId per A2A spec) instead of cookie-based session
         # Handle various falsy values: None, empty string, whitespace-only string
         frontend_session_id = None
         if (
@@ -88,13 +91,16 @@ async def _submit_task(
             if isinstance(context_id, str) and context_id.strip():
                 frontend_session_id = context_id.strip()
 
+        user_id = user_identity.get("id")
+        from ....gateway.http_sse.dependencies import SessionLocal
+
         if frontend_session_id:
             session_id = frontend_session_id
             log.info(
                 "%sUsing session ID from frontend request: %s", log_prefix, session_id
             )
         else:
-            # Create new session when frontend doesn't provide one (None, empty, or whitespace-only)
+            # Create new session when frontend doesn't provide one
             session_id = session_manager.create_new_session_id(request)
             log.info(
                 "%sNo valid session ID from frontend, created new session: %s",
@@ -102,43 +108,60 @@ async def _submit_task(
                 session_id,
             )
 
+            # Immediately create session in database if persistence is enabled
+            # This ensures the session exists before any other operations (like artifact listing)
+            if SessionLocal is not None and session_service is not None:
+                db = SessionLocal()
+                try:
+                    session_service.create_session(
+                        db=db,
+                        user_id=user_id,
+                        agent_id=agent_name,
+                        session_id=session_id,
+                    )
+                    db.commit()
+                    log.info("%sCreated session in database: %s", log_prefix, session_id)
+                except Exception as e:
+                    db.rollback()
+                    log.warning("%sFailed to create session in database: %s", log_prefix, e)
+                finally:
+                    db.close()
+
         log.info(
             "%sUsing ClientID: %s, SessionID: %s", log_prefix, client_id, session_id
         )
 
         # Store message in persistence layer if available
-        user_id = user_identity.get("id")
-        from ....gateway.http_sse.dependencies import SessionLocal
-
-        if is_streaming and SessionLocal is not None:
+        if is_streaming and SessionLocal is not None and session_service is not None:
+            db = SessionLocal()
             try:
-                from ....gateway.http_sse.dependencies import (
-                    create_session_service_with_transaction,
-                )
                 from ....gateway.http_sse.shared.enums import SenderType
 
-                with create_session_service_with_transaction() as (session_service, db):
-                    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
-
-                    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,
-                    )
-
+                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
+
+                session_service.add_message_to_session(
+                    db=db,
+                    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,
+                )
+                db.commit()
             except Exception as e:
+                db.rollback()
                 log.error(
                     "%sFailed to store message in session service: %s", log_prefix, e
                 )
+            finally:
+                db.close()
         else:
             log.debug(
                 "%sNo persistence available or non-streaming - skipping message storage",
@@ -216,6 +239,7 @@ async def send_task_to_agent(
         session_manager=session_manager,
         component=component,
         is_streaming=False,
+        session_service=None,
     )
 
 
@@ -225,6 +249,7 @@ async def subscribe_task_from_agent(
     payload: SendStreamingMessageRequest,
     session_manager: SessionManager = Depends(get_session_manager),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
+    session_service: SessionService = Depends(get_session_business_service),
 ):
     """
     Submits a streaming task request to the specified agent.
@@ -237,6 +262,7 @@ async def subscribe_task_from_agent(
         session_manager=session_manager,
         component=component,
         is_streaming=True,
+        session_service=session_service,
     )
 
 
@@ -302,4 +328,4 @@ async def cancel_agent_task(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=error_resp.model_dump(exclude_none=True),
-        )
+        )

solace_agent_mesh/gateway/http_sse/services/session_service.py

@@ -2,6 +2,7 @@ import uuid
 from typing import TYPE_CHECKING, Optional
 
 from solace_ai_connector.common.log import log
+from sqlalchemy.orm import Session as DbSession
 
 from ..repository import (
     IMessageRepository,
@@ -13,6 +14,7 @@ from ..repository import (
 from ..shared.enums import MessageType, SenderType
 from ..shared.types import PaginationInfo, SessionId, UserId
 from ..shared import now_epoch_ms
+from ..shared.pagination import PaginationParams, PaginatedResponse, get_pagination_or_default
 
 if TYPE_CHECKING:
     from ..component import WebUIBackendComponent
@@ -21,38 +23,65 @@ if TYPE_CHECKING:
 class SessionService:
     def __init__(
         self,
-        session_repository: ISessionRepository,
-        message_repository: IMessageRepository,
         component: "WebUIBackendComponent" = None,
     ):
-        self.session_repository = session_repository
-        self.message_repository = message_repository
         self.component = component
 
+    def _get_repositories(self, db: DbSession):
+        """Create repositories for the given database session."""
+        from ..repository import SessionRepository, MessageRepository
+        session_repository = SessionRepository(db)
+        message_repository = MessageRepository(db)
+        return session_repository, message_repository
+
     def is_persistence_enabled(self) -> bool:
         """Checks if the service is configured with a persistent backend."""
-        # The presence of a database_url on the component is the source of truth
-        # for whether SQL persistence is enabled.
         return self.component and self.component.database_url is not None
 
     def get_user_sessions(
-        self, user_id: UserId, pagination: PaginationInfo | None = None
-    ) -> list[Session]:
+        self,
+        db: DbSession,
+        user_id: UserId,
+        pagination: PaginationParams | None = None
+    ) -> PaginatedResponse[Session]:
+        """
+        Get paginated sessions for a user with full metadata.
+
+        Uses default pagination if none provided (page 1, size 20).
+        Returns paginated response with pageNumber, pageSize, nextPage, totalPages, totalCount.
+        """
         if not user_id or user_id.strip() == "":
             raise ValueError("User ID cannot be empty")
 
-        return self.session_repository.find_by_user(user_id, pagination)
+        pagination = get_pagination_or_default(pagination)
+        session_repository, _ = self._get_repositories(db)
+
+        pagination_info = PaginationInfo(
+            page=pagination.page_number,
+            page_size=pagination.page_size,
+            total_items=0,
+            total_pages=0,
+            has_next=False,
+            has_previous=False,
+        )
+
+        sessions = session_repository.find_by_user(user_id, pagination_info)
+        total_count = session_repository.count_by_user(user_id)
+
+        return PaginatedResponse.create(sessions, total_count, pagination)
 
     def get_session_details(
-        self, session_id: SessionId, user_id: UserId
+        self, db: DbSession, session_id: SessionId, user_id: UserId
     ) -> Session | None:
         if not self._is_valid_session_id(session_id):
             return None
 
-        return self.session_repository.find_user_session(session_id, user_id)
+        session_repository, _ = self._get_repositories(db)
+        return session_repository.find_user_session(session_id, user_id)
 
     def get_session_history(
         self,
+        db: DbSession,
         session_id: SessionId,
         user_id: UserId,
         pagination: PaginationInfo | None = None,
@@ -60,7 +89,8 @@ class SessionService:
         if not self._is_valid_session_id(session_id):
             return None
 
-        result = self.session_repository.find_user_session_with_messages(
+        session_repository, _ = self._get_repositories(db)
+        result = session_repository.find_user_session_with_messages(
             session_id, user_id, pagination
         )
         if not result:
@@ -75,6 +105,7 @@ class SessionService:
 
     def create_session(
         self,
+        db: DbSession,
         user_id: UserId,
         name: str | None = None,
         agent_id: str | None = None,
@@ -90,8 +121,6 @@ class SessionService:
         if not session_id:
             session_id = str(uuid.uuid4())
 
-        # Leave name as None/empty - frontend will generate display name if needed
-
         now_ms = now_epoch_ms()
         session = Session(
             id=session_id,
@@ -102,10 +131,8 @@ class SessionService:
             updated_time=now_ms,
         )
 
-        if not session:
-            raise ValueError(f"Failed to create session for {session_id}")
-
-        created_session = self.session_repository.save(session)
+        session_repository, _ = self._get_repositories(db)
+        created_session = session_repository.save(session)
         log.info("Created new session %s for user %s", created_session.id, user_id)
 
         if not created_session:
@@ -114,7 +141,7 @@ class SessionService:
         return created_session
 
     def update_session_name(
-        self, session_id: SessionId, user_id: UserId, name: str
+        self, db: DbSession, session_id: SessionId, user_id: UserId, name: str
     ) -> Session | None:
         if not self._is_valid_session_id(session_id):
             raise ValueError("Invalid session ID")
@@ -125,23 +152,25 @@ class SessionService:
         if len(name.strip()) > 255:
             raise ValueError("Session name cannot exceed 255 characters")
 
-        session = self.session_repository.find_user_session(session_id, user_id)
+        session_repository, _ = self._get_repositories(db)
+        session = session_repository.find_user_session(session_id, user_id)
         if not session:
             return None
 
         session.update_name(name)
-        updated_session = self.session_repository.save(session)
+        updated_session = session_repository.save(session)
 
         log.info("Updated session %s name to '%s'", session_id, name)
         return updated_session
 
     def delete_session_with_notifications(
-        self, session_id: SessionId, user_id: UserId
+        self, db: DbSession, session_id: SessionId, user_id: UserId
     ) -> bool:
         if not self._is_valid_session_id(session_id):
             raise ValueError("Invalid session ID")
 
-        session = self.session_repository.find_user_session(session_id, user_id)
+        session_repository, _ = self._get_repositories(db)
+        session = session_repository.find_user_session(session_id, user_id)
         if not session:
             log.warning(
                 "Attempted to delete non-existent session %s by user %s",
@@ -158,7 +187,7 @@ class SessionService:
             )
             return False
 
-        deleted = self.session_repository.delete(session_id, user_id)
+        deleted = session_repository.delete(session_id, user_id)
         if not deleted:
             return False
 
@@ -171,6 +200,7 @@ class SessionService:
 
     def add_message_to_session(
         self,
+        db: DbSession,
         session_id: SessionId,
         user_id: UserId,
         message: str,
@@ -185,9 +215,11 @@ class SessionService:
         if not message or message.strip() == "":
             raise ValueError("Message cannot be empty")
 
-        session = self.session_repository.find_user_session(session_id, user_id)
+        session_repository, message_repository = self._get_repositories(db)
+        session = session_repository.find_user_session(session_id, user_id)
         if not session:
             session = self.create_session(
+                db=db,
                 user_id=user_id,
                 agent_id=agent_id,
                 session_id=session_id,
@@ -203,10 +235,10 @@ class SessionService:
             created_time=now_epoch_ms(),
         )
 
-        saved_message = self.message_repository.save(message_entity)
+        saved_message = message_repository.save(message_entity)
 
         session.mark_activity()
-        self.session_repository.save(session)
+        session_repository.save(session)
 
         log.info("Added message to session %s from %s", session_id, sender_name)
         return saved_message
@@ -257,4 +289,4 @@ class SessionService:
                 "Failed to publish session deletion event to agent %s: %s",
                 agent_id,
                 e,
-            )
+            )