solace-agent-mesh 1.4.12__py3-none-any.whl → 1.5.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -8,14 +8,16 @@ 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,
     UpdateSessionRequest,
 )
-from .dto.responses.session_responses import MessageResponse, SessionResponse
+from .dto.requests.task_requests import SaveTaskRequest
+from .dto.responses.session_responses import SessionResponse
+from .dto.responses.task_responses import TaskResponse, TaskListResponse
 
 router = APIRouter()
 
+SESSION_NOT_FOUND_MSG = "Session not found."
 
 
 @router.get("/sessions", response_model=PaginatedResponse[SessionResponse])
@@ -27,7 +29,6 @@ async def get_all_sessions(
     session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
-    log.info(f"User '{user_id}' is listing sessions with pagination (page={page_number}, size={page_size})")
 
     try:
         pagination = PaginationParams(page_number=page_number, page_size=page_size)
@@ -52,7 +53,7 @@ async def get_all_sessions(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to retrieve sessions",
-        )
+        ) from e
 
 
 @router.get("/sessions/{session_id}", response_model=DataResponse[SessionResponse])
@@ -63,7 +64,6 @@ async def get_session(
     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)
 
     try:
         if (
@@ -72,7 +72,7 @@ async def get_session(
             or session_id in ["null", "undefined"]
         ):
             raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
         request_dto = GetSessionRequest(session_id=session_id, user_id=user_id)
@@ -83,7 +83,7 @@ async def get_session(
 
         if not session_domain:
             raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
         log.info("User %s authorized. Fetching session_id: %s", user_id, session_id)
@@ -111,19 +111,27 @@ async def get_session(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to retrieve session",
-        )
+        ) from e
 
 
-@router.get("/sessions/{session_id}/messages")
-async def get_session_history(
+@router.post("/sessions/{session_id}/chat-tasks", response_model=TaskResponse)
+async def save_task(
     session_id: str,
+    request: SaveTaskRequest,
     db: Session = Depends(get_db),
     user: dict = Depends(get_current_user),
     session_service: SessionService = Depends(get_session_business_service),
 ):
+    """
+    Save a complete task interaction (upsert).
+    Creates a new task or updates an existing one.
+    """
     user_id = user.get("id")
     log.info(
-        "User %s attempting to fetch history for session_id: %s", user_id, session_id
+        "User %s attempting to save task %s for session %s",
+        user_id,
+        request.task_id,
+        session_id,
     )
 
     try:
@@ -133,44 +141,203 @@ async def get_session_history(
             or session_id in ["null", "undefined"]
         ):
             raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
-        request_dto = GetSessionHistoryRequest(session_id=session_id, user_id=user_id)
+        # Check if task already exists to determine status code
+        from ..repository.chat_task_repository import ChatTaskRepository
+
+        task_repo = ChatTaskRepository(db)
+        existing_task = task_repo.find_by_id(request.task_id, user_id)
+        is_update = existing_task is not None
 
-        history_domain = session_service.get_session_history(
+        # Save the task - pass strings directly
+        saved_task = session_service.save_task(
             db=db,
-            session_id=request_dto.session_id,
-            user_id=request_dto.user_id,
-            pagination=request_dto.pagination,
+            task_id=request.task_id,
+            session_id=session_id,
+            user_id=user_id,
+            user_message=request.user_message,
+            message_bubbles=request.message_bubbles,  # Already a string
+            task_metadata=request.task_metadata,  # Already a string
+        )
+
+        log.info(
+            "Task %s %s successfully for session %s",
+            request.task_id,
+            "updated" if is_update else "created",
+            session_id,
+        )
+
+        # Convert to response DTO
+        response = TaskResponse(
+            task_id=saved_task.id,
+            session_id=saved_task.session_id,
+            user_message=saved_task.user_message,
+            message_bubbles=saved_task.message_bubbles,
+            task_metadata=saved_task.task_metadata,
+            created_time=saved_task.created_time,
+            updated_time=saved_task.updated_time,
         )
 
-        if not history_domain:
+        return response
+
+    except ValueError as e:
+        log.warning("Validation error saving task %s: %s", request.task_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+        ) from e
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(
+            "Error saving task %s for session %s for user %s: %s",
+            request.task_id,
+            session_id,
+            user_id,
+            e,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to save task",
+        ) from e
+
+
+@router.get("/sessions/{session_id}/chat-tasks", response_model=TaskListResponse)
+async def get_session_tasks(
+    session_id: str,
+    db: Session = Depends(get_db),
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_business_service),
+):
+    """
+    Get all tasks for a session.
+    Returns tasks in chronological order.
+    """
+    user_id = user.get("id")
+    log.info(
+        "User %s attempting to fetch tasks for session_id: %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."
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
+        # Get tasks from service
+        tasks = session_service.get_session_tasks(
+            db=db, session_id=session_id, user_id=user_id
+        )
+
         log.info(
-            "User %s authorized. Fetching history for session_id: %s",
+            "User %s authorized. Fetched %d tasks for session_id: %s",
             user_id,
+            len(tasks),
+            session_id,
+        )
+
+        # Convert to response DTOs
+        task_responses = []
+        for task in tasks:
+            task_response = TaskResponse(
+                task_id=task.id,
+                session_id=task.session_id,
+                user_message=task.user_message,
+                message_bubbles=task.message_bubbles,
+                task_metadata=task.task_metadata,
+                created_time=task.created_time,
+                updated_time=task.updated_time,
+            )
+            task_responses.append(task_response)
+
+        return TaskListResponse(tasks=task_responses)
+
+    except ValueError as e:
+        log.warning("Validation error fetching tasks for session %s: %s", session_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
+        ) from e
+    except HTTPException:
+        raise
+    except Exception as e:
+        log.error(
+            "Error fetching tasks for session %s for user %s: %s",
             session_id,
+            user_id,
+            e,
         )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve session tasks",
+        ) from e
+
+
+@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),
+):
+    """
+    Get session message history.
+    Loads from chat_tasks and flattens message_bubbles for backward compatibility.
+    """
+    user_id = user.get("id")
+    log.info(
+        "User %s attempting to fetch history for session_id: %s", user_id, session_id
+    )
 
-        message_responses = []
-        for message_domain in history_domain.messages:
-            message_response = MessageResponse(
-                id=message_domain.id,
-                session_id=message_domain.session_id,
-                message=message_domain.message,
-                sender_type=message_domain.sender_type,
-                sender_name=message_domain.sender_name,
-                message_type=message_domain.message_type,
-                created_time=message_domain.created_time,
+    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_MSG
             )
-            message_responses.append(message_response)
 
-        return message_responses
+        # Use task-based message retrieval (returns list of dicts)
+        messages = session_service.get_session_messages_from_tasks(
+            db=db, session_id=session_id, user_id=user_id
+        )
+
+        log.info(
+            "User %s authorized. Fetched %d messages for session_id: %s",
+            user_id,
+            len(messages),
+            session_id,
+        )
+
+        # Convert snake_case to camelCase for backwards compatibility
+        camel_case_messages = []
+        for msg in messages:
+            camel_msg = {
+                "id": msg["id"],
+                "sessionId": msg["session_id"],
+                "message": msg["message"],
+                "senderType": msg["sender_type"],
+                "senderName": msg["sender_name"],
+                "messageType": msg["message_type"],
+                "createdTime": msg["created_time"],
+            }
+            camel_case_messages.append(camel_msg)
+
+        return camel_case_messages
 
+    except ValueError as e:
+        log.warning(
+            "Validation error fetching history for session %s: %s", session_id, e
+        )
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
+        ) from e
     except HTTPException:
         raise
     except Exception as e:
@@ -183,7 +350,7 @@ async def get_session_history(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to retrieve session history",
-        )
+        ) from e
 
 
 @router.patch("/sessions/{session_id}", response_model=SessionResponse)
@@ -204,7 +371,7 @@ async def update_session_name(
             or session_id in ["null", "undefined"]
         ):
             raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
         request_dto = UpdateSessionRequest(
@@ -220,7 +387,7 @@ async def update_session_name(
 
         if not updated_domain:
             raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
         log.info("Session %s updated successfully", session_id)
@@ -240,7 +407,7 @@ async def update_session_name(
         log.warning("Validation error updating session %s: %s", session_id, e)
         raise HTTPException(
             status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
-        )
+        ) from e
     except Exception as e:
         log.error(
             "Error updating session %s for user %s: %s",
@@ -251,7 +418,7 @@ async def update_session_name(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to update session",
-        )
+        ) from e
 
 
 @router.delete("/sessions/{session_id}", status_code=status.HTTP_204_NO_CONTENT)
@@ -265,20 +432,33 @@ async def delete_session(
     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_MSG
+            )
+
         deleted = session_service.delete_session_with_notifications(
             db=db, session_id=session_id, user_id=user_id
         )
 
         if not deleted:
             raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND, detail="Session not found."
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
         log.info("Session %s deleted successfully", session_id)
 
+    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))
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        ) from e
     except Exception as e:
         log.error(
             "Error deleting session %s for user %s: %s",
@@ -289,4 +469,4 @@ async def delete_session(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to delete session",
-        )
+        ) from e

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -2,20 +2,28 @@
 API Router for submitting and managing tasks to agents.
 """
 
+import yaml
+from datetime import datetime
 from fastapi import (
     APIRouter,
     Depends,
     HTTPException,
     Request as FastAPIRequest,
+    Response,
     status,
 )
-from typing import Union
+from fastapi.exceptions import RequestValidationError
+from typing import List, Optional, Union
 
 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 ....gateway.http_sse.repository.interfaces import ITaskRepository
+from ....gateway.http_sse.repository.entities import Task
+from ....gateway.http_sse.shared.types import PaginationParams, UserId
+from ..utils.stim_utils import create_stim_from_task_data
 
 from a2a.types import (
     CancelTaskRequest,
@@ -31,7 +39,12 @@ from ....gateway.http_sse.dependencies import (
     get_sac_component,
     get_task_service,
     get_session_business_service,
+    get_task_repository,
+    get_user_id,
+    get_user_config,
+    get_session_business_service,
 )
+from ....gateway.http_sse.services.session_service import SessionService
 
 from typing import TYPE_CHECKING
 
@@ -58,7 +71,7 @@ async def _submit_task(
 
     if not agent_name:
         raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
             detail="Missing 'agent_name' in request payload message metadata.",
         )
 
@@ -120,10 +133,14 @@ async def _submit_task(
                         session_id=session_id,
                     )
                     db.commit()
-                    log.info("%sCreated session in database: %s", log_prefix, session_id)
+                    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)
+                    log.warning(
+                        "%sFailed to create session in database: %s", log_prefix, e
+                    )
                 finally:
                     db.close()
 
@@ -131,43 +148,6 @@ async def _submit_task(
             "%sUsing ClientID: %s, SessionID: %s", log_prefix, client_id, session_id
         )
 
-        # Store message in persistence layer if available
-        if is_streaming and SessionLocal is not None and session_service is not None:
-            db = SessionLocal()
-            try:
-                from ....gateway.http_sse.shared.enums import SenderType
-
-                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",
-                log_prefix,
-            )
-
         # Use the helper to get the unwrapped parts from the incoming message.
         a2a_parts = a2a.get_parts_from_message(payload.params.message)
 
@@ -222,6 +202,146 @@ async def _submit_task(
         )
 
 
+@router.get("/tasks", response_model=List[Task], tags=["Tasks"])
+async def search_tasks(
+    request: FastAPIRequest,
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    search: Optional[str] = None,
+    page: int = 1,
+    page_size: int = 20,
+    query_user_id: Optional[str] = None,
+    user_id: UserId = Depends(get_user_id),
+    user_config: dict = Depends(get_user_config),
+    repo: ITaskRepository = Depends(get_task_repository),
+):
+    """
+    Lists and searches for historical tasks.
+    - Regular users can only search their own tasks.
+    - Users with the 'tasks:read:all' scope can search for any user's tasks by providing `query_user_id`.
+    """
+    log_prefix = f"[GET /api/v1/tasks] "
+    log.info("%sRequest from user %s", log_prefix, user_id)
+
+    target_user_id = user_id
+    can_query_all = user_config.get("scopes", {}).get("tasks:read:all", False)
+
+    if query_user_id:
+        if can_query_all:
+            target_user_id = query_user_id
+            log.info(
+                "%sAdmin user %s is querying for user %s",
+                log_prefix,
+                user_id,
+                target_user_id,
+            )
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="You do not have permission to query for other users' tasks.",
+            )
+    elif can_query_all:
+        target_user_id = "*"
+        log.info("%sAdmin user %s is querying for all users.", log_prefix, user_id)
+
+    start_time_ms = None
+    if start_date:
+        try:
+            start_time_ms = int(datetime.fromisoformat(start_date).timestamp() * 1000)
+        except ValueError:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid start_date format. Use ISO 8601 format.",
+            )
+
+    end_time_ms = None
+    if end_date:
+        try:
+            end_time_ms = int(datetime.fromisoformat(end_date).timestamp() * 1000)
+        except ValueError:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Invalid end_date format. Use ISO 8601 format.",
+            )
+
+    pagination = PaginationParams(page=page, page_size=page_size)
+
+    try:
+        tasks = repo.search(
+            user_id=target_user_id,
+            start_date=start_time_ms,
+            end_date=end_time_ms,
+            search_query=search,
+            pagination=pagination,
+        )
+        return tasks
+    except Exception as e:
+        log.exception("%sError searching for tasks: %s", log_prefix, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An error occurred while searching for tasks.",
+        )
+
+
+@router.get("/tasks/{task_id}", tags=["Tasks"])
+async def get_task_as_stim_file(
+    task_id: str,
+    request: FastAPIRequest,
+    user_id: UserId = Depends(get_user_id),
+    user_config: dict = Depends(get_user_config),
+    repo: ITaskRepository = Depends(get_task_repository),
+):
+    """
+    Retrieves the complete event history for a single task and returns it as a `.stim` file.
+    """
+    log_prefix = f"[GET /api/v1/tasks/{task_id}] "
+    log.info("%sRequest from user %s", log_prefix, user_id)
+
+    try:
+        result = repo.find_by_id_with_events(task_id)
+        if not result:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Task with ID '{task_id}' not found.",
+            )
+
+        task, events = result
+
+        can_read_all = user_config.get("scopes", {}).get("tasks:read:all", False)
+        if task.user_id != user_id and not can_read_all:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail="You do not have permission to view this task.",
+            )
+
+        # Format into .stim structure
+        stim_data = create_stim_from_task_data(task, events)
+
+        yaml_content = yaml.dump(
+            stim_data,
+            sort_keys=False,
+            allow_unicode=True,
+            indent=2,
+            default_flow_style=False,
+        )
+
+        return Response(
+            content=yaml_content,
+            media_type="application/x-yaml",
+            headers={"Content-Disposition": f'attachment; filename="{task_id}.stim"'},
+        )
+
+    except HTTPException:
+        # Re-raise HTTPExceptions (404, 403, etc.) without modification
+        raise
+    except Exception as e:
+        log.exception("%sError retrieving task: %s", log_prefix, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="An error occurred while retrieving the task.",
+        )
+
+
 @router.post("/message:send", response_model=SendMessageSuccessResponse)
 async def send_task_to_agent(
     request: FastAPIRequest,
@@ -278,6 +398,7 @@ async def cancel_agent_task(
     """
     Sends a cancellation request for a specific task to the specified agent.
     Returns 202 Accepted, as cancellation is asynchronous.
+    Returns 404 if the task context is not found.
     """
     log_prefix = f"[POST /api/v1/tasks/{taskId}:cancel] "
     log.info("%sReceived cancellation request.", log_prefix)
@@ -290,6 +411,11 @@ async def cancel_agent_task(
 
     context = component.task_context_manager.get_context(taskId)
     if not context:
+        log.warning(
+            "%sNo active task context found for task ID: %s",
+            log_prefix,
+            taskId,
+        )
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail=f"No active task context found for task ID: {taskId}",
@@ -328,4 +454,4 @@ async def cancel_agent_task(
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=error_resp.model_dump(exclude_none=True),
-        )
+        )