solace-agent-mesh 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

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

@@ -0,0 +1,37 @@
+"""
+Request DTOs for API endpoints.
+"""
+
+from .session_requests import (
+    GetSessionsRequest,
+    GetSessionRequest,
+    GetSessionHistoryRequest,
+    UpdateSessionRequest,
+    DeleteSessionRequest,
+    CreateSessionRequest,
+)
+from .task_requests import (
+    SendTaskRequest,
+    SubscribeTaskRequest,
+    CancelTaskRequest,
+    GetTaskStatusRequest,
+    TaskFilesInfo,
+    ProcessedTaskRequest,
+)
+
+__all__ = [
+    # Session requests
+    "GetSessionsRequest",
+    "GetSessionRequest", 
+    "GetSessionHistoryRequest",
+    "UpdateSessionRequest",
+    "DeleteSessionRequest",
+    "CreateSessionRequest",
+    # Task requests
+    "SendTaskRequest",
+    "SubscribeTaskRequest",
+    "CancelTaskRequest",
+    "GetTaskStatusRequest",
+    "TaskFilesInfo",
+    "ProcessedTaskRequest",
+]

solace_agent_mesh/gateway/http_sse/api/dto/requests/session_requests.py

@@ -0,0 +1,49 @@
+"""
+Session-related request DTOs.
+"""
+
+from typing import Optional, List
+from pydantic import BaseModel, Field
+
+from ....shared.types import SessionId, UserId, SortInfo, FilterInfo, PaginationInfo
+
+
+class GetSessionsRequest(BaseModel):
+    """Request DTO for retrieving sessions."""
+    user_id: UserId
+    pagination: Optional[PaginationInfo] = None
+    sort: Optional[SortInfo] = None
+    filters: Optional[List[FilterInfo]] = None
+
+
+class GetSessionRequest(BaseModel):
+    """Request DTO for retrieving a specific session."""
+    session_id: SessionId
+    user_id: UserId
+
+
+class GetSessionHistoryRequest(BaseModel):
+    """Request DTO for retrieving session message history."""
+    session_id: SessionId
+    user_id: UserId
+    pagination: Optional[PaginationInfo] = None
+
+
+class UpdateSessionRequest(BaseModel):
+    """Request DTO for updating session details."""
+    session_id: SessionId
+    user_id: UserId
+    name: str = Field(..., min_length=1, max_length=255, description="New session name")
+
+
+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")

solace_agent_mesh/gateway/http_sse/api/dto/requests/task_requests.py

@@ -0,0 +1,66 @@
+"""
+Task-related request DTOs.
+"""
+
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+from fastapi import UploadFile
+
+from ....shared.types import TaskId, UserId, SessionId, AgentId
+
+
+class SendTaskRequest(BaseModel):
+    """Request DTO for sending a non-streaming task."""
+    agent_name: str = Field(..., description="The name of the target A2A agent")
+    message: str = Field(..., description="The user's message or prompt")
+    user_id: UserId
+    client_id: Optional[str] = None
+    session_id: Optional[SessionId] = None
+    
+    class Config:
+        # UploadFile cannot be included in Pydantic models directly
+        # Files will be handled separately in the controller
+        arbitrary_types_allowed = True
+
+
+class SubscribeTaskRequest(BaseModel):
+    """Request DTO for sending a streaming task."""
+    agent_name: str = Field(..., description="The name of the target A2A agent")
+    message: str = Field(..., description="The user's message or prompt")
+    user_id: UserId
+    session_id: Optional[SessionId] = None
+    client_id: Optional[str] = None
+    
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class CancelTaskRequest(BaseModel):
+    """Request DTO for cancelling a task."""
+    task_id: TaskId = Field(..., description="The ID of the task to cancel")
+    client_id: Optional[str] = None
+    user_id: UserId
+
+
+class GetTaskStatusRequest(BaseModel):
+    """Request DTO for getting task status."""
+    task_id: TaskId
+    user_id: UserId
+
+
+class TaskFilesInfo(BaseModel):
+    """Information about uploaded files for a task."""
+    filename: str
+    content_type: str
+    size: int
+    
+    
+class ProcessedTaskRequest(BaseModel):
+    """Internal DTO for processed task request with file information."""
+    agent_name: str
+    message: str
+    user_id: UserId
+    session_id: Optional[SessionId] = None
+    client_id: Optional[str] = None
+    files: List[TaskFilesInfo] = []
+    metadata: Optional[Dict[str, Any]] = None

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

@@ -0,0 +1,43 @@
+"""
+Response DTOs for API endpoints.
+"""
+
+from .session_responses import (
+    MessageResponse,
+    SessionResponse,
+    SessionListResponse,
+    SessionHistoryResponse,
+    SessionCreatedResponse,
+    SessionUpdatedResponse,
+    SessionDeletedResponse,
+)
+from .task_responses import (
+    TaskResponse,
+    SendTaskResponse,
+    SubscribeTaskResponse,
+    CancelTaskResponse,
+    TaskStatusResponse,
+    TaskListResponse,
+    TaskErrorResponse,
+    JSONRPCTaskResponse,
+)
+
+__all__ = [
+    # Session responses
+    "MessageResponse",
+    "SessionResponse",
+    "SessionListResponse",
+    "SessionHistoryResponse",
+    "SessionCreatedResponse",
+    "SessionUpdatedResponse",
+    "SessionDeletedResponse",
+    # Task responses
+    "TaskResponse",
+    "SendTaskResponse",
+    "SubscribeTaskResponse",
+    "CancelTaskResponse",
+    "TaskStatusResponse",
+    "TaskListResponse",
+    "TaskErrorResponse",
+    "JSONRPCTaskResponse",
+]

solace_agent_mesh/gateway/http_sse/api/dto/responses/session_responses.py

@@ -0,0 +1,68 @@
+"""
+Session-related response DTOs.
+"""
+
+from typing import List, Optional
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+from ....shared.types import SessionId, UserId, MessageId, PaginationInfo, Timestamp
+from ....shared.enums import SessionStatus, SenderType, MessageType
+
+
+class MessageResponse(BaseModel):
+    """Response DTO for a chat message."""
+    id: MessageId
+    session_id: SessionId
+    message: str
+    sender_type: SenderType
+    sender_name: str
+    message_type: MessageType = MessageType.TEXT
+    timestamp: datetime
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+
+
+class SessionResponse(BaseModel):
+    """Response DTO for a session."""
+    id: SessionId
+    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
+
+
+class SessionListResponse(BaseModel):
+    """Response DTO for a list of sessions."""
+    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/dto/responses/task_responses.py

@@ -0,0 +1,74 @@
+"""
+Task-related response DTOs.
+"""
+
+from typing import Optional, Dict, Any, List
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+from ....shared.types import TaskId, UserId, SessionId, AgentId
+from ....shared.enums import TaskStatus
+
+
+class TaskResponse(BaseModel):
+    """Response DTO for task information."""
+    task_id: TaskId
+    agent_name: str
+    status: TaskStatus
+    user_id: UserId
+    session_id: Optional[SessionId] = None
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    error_message: Optional[str] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
+class SendTaskResponse(BaseModel):
+    """Response DTO for send task endpoint."""
+    task_id: TaskId
+    message: str = "Task submitted successfully"
+    status: TaskStatus = TaskStatus.PENDING
+
+
+class SubscribeTaskResponse(BaseModel):
+    """Response DTO for subscribe task endpoint."""
+    task_id: TaskId
+    session_id: SessionId
+    message: str = "Streaming task submitted successfully"
+    status: TaskStatus = TaskStatus.PENDING
+
+
+class CancelTaskResponse(BaseModel):
+    """Response DTO for cancel task endpoint."""
+    task_id: TaskId
+    message: str = "Cancellation request sent successfully"
+    cancelled_at: datetime
+
+
+class TaskStatusResponse(BaseModel):
+    """Response DTO for task status."""
+    task: TaskResponse
+
+
+class TaskListResponse(BaseModel):
+    """Response DTO for listing tasks."""
+    tasks: List[TaskResponse]
+    total_count: int
+
+
+class TaskErrorResponse(BaseModel):
+    """Response DTO for task errors."""
+    task_id: TaskId
+    error_type: str
+    error_message: str
+    error_details: Optional[Dict[str, Any]] = None
+    occurred_at: datetime
+
+
+class JSONRPCTaskResponse(BaseModel):
+    """Response DTO matching the existing JSONRPC format."""
+    result: Dict[str, Any]
+    error: Optional[Dict[str, Any]] = None
+    id: Optional[str] = None
+    jsonrpc: str = "2.0"

solace_agent_mesh/gateway/http_sse/app.py

@@ -4,6 +4,9 @@ Defines configuration schema and programmatically creates the WebUIBackendCompon
 """
 
 from typing import Any, Dict, List
+import os
+from alembic import command
+from alembic.config import Config
 from solace_ai_connector.common.log import log
 
 from ...gateway.http_sse.component import WebUIBackendComponent
@@ -183,7 +186,34 @@ class WebUIBackendApp(BaseGatewayApp):
             "%s Initializing WebUIBackendApp...",
             app_info.get("name", "WebUIBackendApp"),
         )
-        super().__init__(app_info=app_info, **kwargs)
+        super().__init__(app_info, **kwargs)
+
+        try:
+            
+            alembic_ini_path = os.path.join(os.path.dirname(__file__), "alembic.ini")
+            if os.path.exists(alembic_ini_path):
+                log.debug("Loading Alembic configuration from alembic.ini.")
+                alembic_cfg = Config(alembic_ini_path)
+            else:
+                log.warning(
+                    "alembic.ini not found. Falling back to programmatic configuration."
+                )
+                alembic_cfg = Config()
+                alembic_cfg.set_main_option(
+                    "script_location",
+                    os.path.join(os.path.dirname(__file__), "alembic"),
+                )
+            
+            session_service_config = self.get_config("session_service", {})
+            db_url = session_service_config.get("database_url")
+            if db_url:
+                alembic_cfg.set_main_option("sqlalchemy.url", db_url)
+                command.upgrade(alembic_cfg, "head")
+            else:
+                log.warning("Database URL not configured. Skipping migrations.")
+        except Exception as e:
+            log.warning(f"Alembic migration failed: {e}")
+
         log.debug("%s WebUIBackendApp initialization complete.", self.name)
 
     def _get_gateway_component_class(self) -> type[BaseGatewayComponent]:

solace_agent_mesh/gateway/http_sse/application/__init__.py

@@ -0,0 +1,3 @@
+from .services.session_service import SessionService
+
+__all__ = ["SessionService"]

solace_agent_mesh/gateway/http_sse/application/services/__init__.py

@@ -0,0 +1,3 @@
+from .session_service import SessionService
+
+__all__ = ["SessionService"]

solace_agent_mesh/gateway/http_sse/application/services/session_service.py

@@ -0,0 +1,135 @@
+import uuid
+from datetime import datetime, timezone
+
+from solace_ai_connector.common.log import log
+
+from ...domain.entities.session import Message, Session, SessionHistory
+from ...domain.repositories.session_repository import (
+    IMessageRepository,
+    ISessionRepository,
+)
+from ...shared.enums import MessageType, SenderType, SessionStatus
+from ...shared.types import PaginationInfo, SessionId, UserId
+
+
+class SessionService:
+    def __init__(
+        self,
+        session_repository: ISessionRepository,
+        message_repository: IMessageRepository,
+    ):
+        self.session_repository = session_repository
+        self.message_repository = message_repository
+
+    def get_user_sessions(
+        self, user_id: UserId, pagination: PaginationInfo | None = None
+    ) -> list[Session]:
+        return self.session_repository.get_by_user_id(user_id, pagination)
+
+    def get_session(self, session_id: SessionId, user_id: UserId) -> Session | None:
+        return self.session_repository.get_user_session(session_id, user_id)
+
+    def get_session_history(
+        self,
+        session_id: SessionId,
+        user_id: UserId,
+        pagination: PaginationInfo | None = None,
+    ) -> SessionHistory | None:
+        session = self.session_repository.get_user_session(session_id, user_id)
+        if not session:
+            return None
+
+        messages = self.message_repository.get_by_session_id(session_id, pagination)
+
+        return SessionHistory(
+            session=session,
+            messages=messages,
+            total_message_count=len(messages),
+        )
+
+    def create_session(
+        self,
+        user_id: UserId,
+        name: str | None = None,
+        agent_id: str | None = None,
+        session_id: str | None = None,
+    ) -> Session:
+        if not user_id or user_id.strip() == "":
+            raise ValueError(f"user_id cannot be None or empty. Received: {user_id}")
+
+        if not session_id:
+            session_id = str(uuid.uuid4())
+
+        now = datetime.now(timezone.utc)
+        session = Session(
+            id=session_id,
+            user_id=user_id,
+            name=name,
+            agent_id=agent_id,
+            status=SessionStatus.ACTIVE,
+            created_at=now,
+            updated_at=now,
+            last_activity=now,
+        )
+
+        return self.session_repository.create(session)
+
+    def update_session_name(
+        self, session_id: SessionId, user_id: UserId, name: str
+    ) -> Session | None:
+        session = self.session_repository.get_user_session(session_id, user_id)
+        if not session:
+            return None
+
+        session.update_name(name)
+        return self.session_repository.update(session)
+
+    def delete_session(self, session_id: SessionId, user_id: UserId) -> bool:
+        session = self.session_repository.get_user_session(session_id, user_id)
+        if not session:
+            return False
+
+        if not session.can_be_deleted_by_user(user_id):
+            return False
+
+        self.message_repository.delete_by_session_id(session_id)
+        return self.session_repository.delete(session_id, user_id)
+
+    def add_message_to_session(
+        self,
+        session_id: SessionId,
+        user_id: UserId,
+        message: str,
+        sender_type: SenderType,
+        sender_name: str,
+        agent_id: str | None = None,
+    ) -> Message | None:
+        if not user_id or user_id.strip() == "":
+            raise ValueError(f"user_id cannot be None or empty. Received: {user_id}")
+
+        session = self.session_repository.get_user_session(session_id, user_id)
+        if not session:
+            log.error(f"Session {session_id} not found for user {user_id}")
+            return None
+
+        if agent_id and not session.agent_id:
+            session.agent_id = agent_id
+            self.session_repository.update(session)
+            log.info(f"Updated session {session_id} with agent_id: {agent_id}")
+
+        message_entity = Message(
+            id=str(uuid.uuid4()),
+            session_id=session_id,
+            message=message,
+            sender_type=sender_type,
+            sender_name=sender_name,
+            message_type=MessageType.TEXT,
+            created_at=datetime.now(timezone.utc),
+        )
+
+        message_entity.validate_message_content()
+
+        session.mark_activity()
+        self.session_repository.update(session)
+
+        return self.message_repository.create(message_entity)