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

solace_agent_mesh/gateway/http_sse/dependencies.py

@@ -3,24 +3,31 @@ Defines FastAPI dependency injectors to access shared resources
 managed by the WebUIBackendComponent.
 """
 
-from collections.abc import Callable
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
 from typing import TYPE_CHECKING, Any
 
 from fastapi import Depends, HTTPException, Request, status
 from solace_ai_connector.common.log import log
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Session, sessionmaker
 
 from ...common.agent_registry import AgentRegistry
 from ...common.middleware.config_resolver import ConfigResolver
 from ...common.services.identity_service import BaseIdentityService
 from ...core_a2a.service import CoreA2AService
 from ...gateway.base.task_context import TaskContextManager
-from ...gateway.http_sse.services.agent_service import AgentService
+from ...gateway.http_sse.services.agent_card_service import AgentCardService
 from ...gateway.http_sse.services.people_service import PeopleService
 from ...gateway.http_sse.services.task_service import TaskService
 from ...gateway.http_sse.session_manager import SessionManager
 from ...gateway.http_sse.sse_manager import SSEManager
-from .application.services.session_service import SessionService
-from .infrastructure.persistence_service import PersistenceService
+from .services.session_service import SessionService
+from .repository import (
+    Message,
+    MessageRepository,
+    SessionRepository,
+)
 
 try:
     from google.adk.artifacts import BaseArtifactService
@@ -34,7 +41,7 @@ if TYPE_CHECKING:
     from gateway.http_sse.component import WebUIBackendComponent
 
 sac_component_instance: "WebUIBackendComponent" = None
-persistence_service_instance: "PersistenceService" = None
+SessionLocal: sessionmaker = None
 
 api_config: dict[str, Any] | None = None
 
@@ -49,27 +56,15 @@ def set_component_instance(component: "WebUIBackendComponent"):
         log.warning("[Dependencies] SAC Component instance already set.")
 
 
-def set_persistence_service(persistence_service: "PersistenceService"):
-    """Called by the component during its startup to provide its instance."""
-    global persistence_service_instance
-    if persistence_service_instance is None:
-        persistence_service_instance = persistence_service
-        log.info("[Dependencies] Persistence Service instance provided.")
+def init_database(database_url: str):
+    """Initialize database with direct sessionmaker."""
+    global SessionLocal
+    if SessionLocal is None:
+        engine = create_engine(database_url)
+        SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        log.info("[Dependencies] Database initialized.")
     else:
-        log.warning("[Dependencies] Persistence Service instance already set.")
-
-
-def get_persistence_service() -> "PersistenceService":
-    """FastAPI dependency to get the PersistenceService instance."""
-    if persistence_service_instance is None:
-        log.warning(
-            "[Dependencies] PersistenceService not available - running in compatibility mode"
-        )
-        raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail="Persistence service not available in compatibility mode.",
-        )
-    return persistence_service_instance
+        log.warning("[Dependencies] Database already initialized.")
 
 
 def set_api_config(config: dict[str, Any]):
@@ -323,12 +318,12 @@ def get_task_context_manager_from_component(
     return component.task_context_manager
 
 
-def get_agent_service(
+def get_agent_card_service(
     registry: AgentRegistry = Depends(get_agent_registry),
-) -> AgentService:
-    """FastAPI dependency to get an instance of AgentService."""
-    log.debug("[Dependencies] get_agent_service called")
-    return AgentService(agent_registry=registry)
+) -> AgentCardService:
+    """FastAPI dependency to get an instance of AgentCardService."""
+    log.debug("[Dependencies] get_agent_card_service called")
+    return AgentCardService(agent_registry=registry)
 
 
 def get_task_service(
@@ -357,63 +352,131 @@ def get_task_service(
     )
 
 
-def get_session_service(
-    component: "WebUIBackendComponent" = Depends(get_sac_component),
-) -> SessionService:
-    log.debug("[Dependencies] get_session_service called")
-
-    if (
-        hasattr(component, "persistence_service")
-        and component.persistence_service is not None
-    ):
-        log.debug("Using database-backed session service")
-        container = component.persistence_service.container
-        return container.get_session_service()
-    else:
-        log.debug("No database configured - session persistence not available")
+def get_db() -> Generator[Session, None, None]:
+    if SessionLocal is None:
         raise HTTPException(
             status_code=status.HTTP_501_NOT_IMPLEMENTED,
-            detail="Session management requires database configuration. Configure 'database_url' in your gateway configuration.",
+            detail="Session management requires database configuration.",
         )
+    db = SessionLocal()
+    try:
+        yield db
+        db.commit()
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()
+
+
+
+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)
+
+
+@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 datetime import datetime, timezone
+                from .shared.enums import MessageType
+                
+                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_at=datetime.now(timezone.utc),
+                )
+                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 datetime import datetime, timezone
+                from .repository.entities import Session
+                
+                if not session_id:
+                    session_id = str(uuid4())
+                
+                # Leave name as None/empty - frontend will generate display name if needed
+                
+                now = datetime.now(timezone.utc)
+                session = Session(
+                    id=session_id,
+                    user_id=user_id,
+                    name=name,
+                    agent_id=agent_id,
+                    created_at=now,
+                    updated_at=now,
+                    last_activity=now,
+                )
+                
+                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(
     component: "WebUIBackendComponent" = Depends(get_sac_component),
 ) -> Callable[[str, str], bool]:
-    """
-    FastAPI dependency that returns a session validator function.
-
-    With database: Validates sessions against database
-    Without database: Validates sessions using basic checks (session exists in recent activity)
-    """
     log.debug("[Dependencies] get_session_validator called")
 
-    # Check if component has a persistence service (database-backed)
-    if (
-        hasattr(component, "persistence_service")
-        and component.persistence_service is not None
-    ):
+    if SessionLocal:
         log.debug("Using database-backed session validation")
 
         def validate_with_database(session_id: str, user_id: str) -> bool:
-            container = component.persistence_service.container
-            session_service = container.get_session_service()
-            session_domain = session_service.get_session(
-                session_id=session_id, user_id=user_id
-            )
-            return session_domain is not None
+            try:
+                with create_session_service_with_transaction() as (session_service, db):
+                    session_domain = session_service.get_session(session_id, user_id)
+                    return session_domain is not None
+            except:
+                return False
 
         return validate_with_database
     else:
         log.debug("No database configured - using basic session validation")
 
         def validate_without_database(session_id: str, user_id: str) -> bool:
-            """Basic validation: check session ID format and user authentication"""
-            # Validate session ID format (should be web-session-* format from SessionManager)
             if not session_id or not session_id.startswith("web-session-"):
                 return False
-            # If user_id is provided (authenticated), allow access
-            # This provides basic security while allowing filesystem-based artifacts
             return bool(user_id)
 
         return validate_without_database

solace_agent_mesh/gateway/http_sse/main.py

@@ -8,8 +8,9 @@ from a2a.types import InternalError, JSONRPCError
 from a2a.types import JSONRPCResponse as A2AJSONRPCResponse
 from alembic import command
 from alembic.config import Config
-from fastapi import FastAPI, HTTPException, status
+from fastapi import FastAPI, HTTPException
 from fastapi import Request as FastAPIRequest
+from fastapi import status
 from fastapi.exceptions import RequestValidationError
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
@@ -20,7 +21,7 @@ from starlette.staticfiles import StaticFiles
 from ...common import a2a
 from ...gateway.http_sse import dependencies
 from ...gateway.http_sse.routers import (
-    agents,
+    agent_cards,
     artifacts,
     auth,
     config,
@@ -31,10 +32,9 @@ from ...gateway.http_sse.routers import (
 )
 
 # Import persistence-aware controllers
-from .api.controllers.session_controller import router as session_router
-from .api.controllers.task_controller import router as task_router
-from .api.controllers.user_controller import router as user_router
-from .infrastructure.persistence.database_service import DatabaseService
+from .routers.sessions import router as session_router
+from .routers.tasks import router as task_router
+from .routers.users import router as user_router
 
 if TYPE_CHECKING:
     from gateway.http_sse.component import WebUIBackendComponent
@@ -46,39 +46,25 @@ app = FastAPI(
 )
 
 
-def setup_dependencies(component: "WebUIBackendComponent", persistence_service=None):
+def setup_dependencies(component: "WebUIBackendComponent", database_url: str = None):
     """
-    This function initializes the modern architecture while maintaining full
+    This function initializes the simplified architecture while maintaining full
     backward compatibility with existing API contracts.
 
-    If persistence_service is None, runs in compatibility mode with in-memory sessions.
+    If database_url is None, runs in compatibility mode with in-memory sessions.
     """
 
-    if persistence_service:
-        database_url = persistence_service.engine.url.__str__()
-        global database_service
-        database_service = DatabaseService(database_url)
-        log.info("Database service initialized")
-
-        from .infrastructure.dependency_injection.container import initialize_container
-
-        initialize_container(database_url)
-        log.info("Persistence enabled - sessions will be stored in database")
-    else:
-        from .infrastructure.dependency_injection.container import initialize_container
-
-        initialize_container()
-        log.warning(
-            "No persistence service provided - using in-memory session storage (data not persisted across restarts)"
-        )
-        log.info("This maintains backward compatibility for existing SAM installations")
-
     dependencies.set_component_instance(component)
 
-    if persistence_service:
+    if database_url:
+        dependencies.init_database(database_url)
+        log.info("Persistence enabled - sessions will be stored in database")
+        
         log.info("Checking database migrations...")
         try:
-            inspector = sa.inspect(persistence_service.engine)
+            from sqlalchemy import create_engine
+            engine = create_engine(database_url)
+            inspector = sa.inspect(engine)
             existing_tables = inspector.get_table_names()
 
             if not existing_tables or "sessions" not in existing_tables:
@@ -108,10 +94,11 @@ def setup_dependencies(component: "WebUIBackendComponent", persistence_service=N
                 log.info("Database migrations complete.")
             except Exception as migration_error:
                 log.warning(f"Migration failed but continuing: {migration_error}")
-
-        dependencies.set_persistence_service(persistence_service)
     else:
-        log.info("Skipping database migrations - no persistence service configured")
+        log.warning(
+            "No database URL provided - using in-memory session storage (data not persisted across restarts)"
+        )
+        log.info("This maintains backward compatibility for existing SAM installations")
 
     webui_app = component.get_app()
     app_config = {}
@@ -137,7 +124,7 @@ def setup_dependencies(component: "WebUIBackendComponent", persistence_service=N
         "frontend_redirect_url": app_config.get(
             "frontend_redirect_url", "http://localhost:3000"
         ),
-        "persistence_enabled": persistence_service is not None,
+        "persistence_enabled": database_url is not None,
     }
 
     dependencies.set_api_config(api_config_dict)
@@ -492,7 +479,7 @@ def setup_dependencies(component: "WebUIBackendComponent", persistence_service=N
 
     # Mount new A2A SDK routers with different paths to avoid conflicts
     app.include_router(config.router, prefix=api_prefix, tags=["Config"])
-    app.include_router(agents.router, prefix=api_prefix, tags=["Agents"])
+    app.include_router(agent_cards.router, prefix=api_prefix, tags=["Agent Cards"])
     # New A2A message endpoints (non-conflicting paths)
     app.include_router(
         tasks.router, prefix=api_prefix, tags=["A2A Messages"]

solace_agent_mesh/gateway/http_sse/repository/__init__.py

@@ -0,0 +1,37 @@
+"""
+Repository layer containing all data access logic organized by entity type.
+"""
+
+# Interfaces
+from .interfaces import IMessageRepository, ISessionRepository
+
+# Implementations
+from .message_repository import MessageRepository
+from .session_repository import SessionRepository
+
+# Entities (re-exported for convenience)
+from .entities.session import Session
+from .entities.message import Message
+from .entities.session_history import SessionHistory
+
+# Models (re-exported for convenience)
+from .models.base import Base
+from .models.session_model import SessionModel
+from .models.message_model import MessageModel
+
+__all__ = [
+    # Interfaces
+    "IMessageRepository",
+    "ISessionRepository",
+    # Implementations
+    "MessageRepository", 
+    "SessionRepository",
+    # Entities
+    "Message",
+    "Session", 
+    "SessionHistory",
+    # Models
+    "Base",
+    "MessageModel",
+    "SessionModel",
+]

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

@@ -0,0 +1,9 @@
+"""
+Domain entities for the repository layer.
+"""
+
+from .message import Message
+from .session import Session
+from .session_history import SessionHistory
+
+__all__ = ["Message", "Session", "SessionHistory"]

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

@@ -0,0 +1,41 @@
+"""
+Message domain entity.
+"""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from ...shared.enums import MessageType, SenderType
+from ...shared.types import MessageId, SessionId
+
+
+class Message(BaseModel):
+    """Message domain entity with business logic."""
+    
+    id: MessageId
+    session_id: SessionId
+    message: str
+    sender_type: SenderType
+    sender_name: str
+    message_type: MessageType = MessageType.TEXT
+    created_at: datetime
+
+    def validate_message_content(self) -> None:
+        """Validate message content."""
+        if not self.message or len(self.message.strip()) == 0:
+            raise ValueError("Message content cannot be empty")
+        if len(self.message) > 10_000_000:
+            raise ValueError("Message content exceeds maximum length (10MB)")
+
+    def is_from_user(self) -> bool:
+        """Check if message is from a user."""
+        return self.sender_type == SenderType.USER
+
+    def is_from_agent(self) -> bool:
+        """Check if message is from an agent."""
+        return self.sender_type == SenderType.AGENT
+
+    def is_system_message(self) -> bool:
+        """Check if message is a system message."""
+        return self.sender_type == SenderType.SYSTEM

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

@@ -0,0 +1,45 @@
+"""
+Session domain entity.
+"""
+
+from datetime import datetime, timezone
+
+from pydantic import BaseModel
+
+from ...shared.types import AgentId, SessionId, UserId
+
+
+class Session(BaseModel):
+    """Session domain entity with business logic."""
+    
+    id: SessionId
+    user_id: UserId
+    name: str | None = None
+    agent_id: AgentId | None = None
+    created_at: datetime
+    updated_at: datetime | None = None
+    last_activity: datetime | None = None
+
+    def update_name(self, new_name: str) -> None:
+        """Update session name with validation."""
+        if not new_name or len(new_name.strip()) == 0:
+            raise ValueError("Session name cannot be empty")
+        if len(new_name) > 255:
+            raise ValueError("Session name cannot exceed 255 characters")
+
+        self.name = new_name.strip()
+        self.updated_at = datetime.now(timezone.utc)
+
+    def mark_activity(self) -> None:
+        """Mark session as having recent activity."""
+        self.last_activity = datetime.now(timezone.utc)
+        self.updated_at = datetime.now(timezone.utc)
+
+
+    def can_be_deleted_by_user(self, user_id: UserId) -> bool:
+        """Check if user can delete this session."""
+        return self.user_id == user_id
+
+    def can_be_accessed_by_user(self, user_id: UserId) -> bool:
+        """Check if user can access this session."""
+        return self.user_id == user_id

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

@@ -0,0 +1,16 @@
+"""
+Session history composite entity.
+"""
+
+from pydantic import BaseModel
+
+from .message import Message
+from .session import Session
+
+
+class SessionHistory(BaseModel):
+    """Composite entity representing a session with its messages."""
+    
+    session: Session
+    messages: list[Message] = []
+    total_message_count: int = 0

solace_agent_mesh/gateway/http_sse/repository/interfaces.py

@@ -0,0 +1,64 @@
+"""
+Repository interfaces defining contracts for data access.
+"""
+
+from abc import ABC, abstractmethod
+
+from ..shared.types import PaginationInfo, SessionId, UserId
+from .entities import Message, Session
+
+
+class ISessionRepository(ABC):
+    """Interface for session data access operations."""
+    
+    @abstractmethod
+    def find_by_user(
+        self, user_id: UserId, pagination: PaginationInfo | None = None
+    ) -> list[Session]:
+        """Find all sessions for a specific user."""
+        pass
+
+    @abstractmethod
+    def find_user_session(
+        self, session_id: SessionId, user_id: UserId
+    ) -> Session | None:
+        """Find a specific session belonging to a user."""
+        pass
+
+    @abstractmethod
+    def save(self, session: Session) -> Session:
+        """Save or update a session."""
+        pass
+
+    @abstractmethod
+    def delete(self, session_id: SessionId, user_id: UserId) -> bool:
+        """Delete a session belonging to a user."""
+        pass
+
+    @abstractmethod
+    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."""
+        pass
+
+
+class IMessageRepository(ABC):
+    """Interface for message data access operations."""
+    
+    @abstractmethod
+    def find_by_session(
+        self, session_id: SessionId, pagination: PaginationInfo | None = None
+    ) -> list[Message]:
+        """Find all messages in a session."""
+        pass
+
+    @abstractmethod
+    def save(self, message: Message) -> Message:
+        """Save or update a message."""
+        pass
+
+    @abstractmethod
+    def delete_by_session(self, session_id: SessionId) -> bool:
+        """Delete all messages in a session."""
+        pass

solace_agent_mesh/gateway/http_sse/repository/message_repository.py

@@ -0,0 +1,78 @@
+"""
+Message repository implementation using SQLAlchemy.
+"""
+
+from sqlalchemy.orm import Session as DBSession
+
+from ..shared.enums import MessageType, SenderType
+from ..shared.types import PaginationInfo, SessionId
+from .entities import Message
+from .interfaces import IMessageRepository
+from .models import MessageModel
+
+
+class MessageRepository(IMessageRepository):
+    """SQLAlchemy implementation of message repository."""
+    
+    def __init__(self, db: DBSession):
+        self.db = db
+
+    def find_by_session(
+        self, session_id: SessionId, pagination: PaginationInfo | None = None
+    ) -> list[Message]:
+        """Find all messages in a session."""
+        query = self.db.query(MessageModel).filter(MessageModel.session_id == session_id)
+
+        if pagination:
+            offset = (pagination.page - 1) * pagination.page_size
+            query = query.offset(offset).limit(pagination.page_size)
+
+        models = query.order_by(MessageModel.created_at.asc()).all()
+        return [self._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()
+
+        if model:
+            # Update existing
+            model.message = message.message
+            model.sender_type = message.sender_type.value
+            model.sender_name = message.sender_name
+        else:
+            # Create new
+            model = MessageModel(
+                id=message.id,
+                session_id=message.session_id,
+                message=message.message,
+                sender_type=message.sender_type.value,
+                sender_name=message.sender_name,
+                created_at=message.created_at,
+            )
+            self.db.add(model)
+
+        self.db.commit()
+        self.db.refresh(model)
+        return self._model_to_entity(model)
+
+    def delete_by_session(self, session_id: SessionId) -> bool:
+        """Delete all messages in a session."""
+        result = (
+            self.db.query(MessageModel)
+            .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."""
+        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,
+        )