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

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

@@ -1,90 +0,0 @@
-from datetime import datetime, timezone
-
-from pydantic import BaseModel
-
-from ...shared.enums import MessageType, SenderType, SessionStatus
-from ...shared.types import AgentId, MessageId, SessionId, UserId
-
-
-class Session(BaseModel):
-    id: SessionId
-    user_id: UserId
-    name: str | None = None
-    agent_id: AgentId | None = None
-    status: SessionStatus = SessionStatus.ACTIVE
-    created_at: datetime
-    updated_at: datetime | None = None
-    last_activity: datetime | None = None
-
-    def update_name(self, new_name: str) -> None:
-        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:
-        self.last_activity = datetime.now(timezone.utc)
-        self.updated_at = datetime.now(timezone.utc)
-
-    def archive(self) -> None:
-        self.status = SessionStatus.ARCHIVED
-        self.updated_at = datetime.now(timezone.utc)
-
-    def activate(self) -> None:
-        self.status = SessionStatus.ACTIVE
-        self.updated_at = datetime.now(timezone.utc)
-
-    def can_be_deleted_by_user(self, user_id: UserId) -> bool:
-        return self.user_id == user_id
-
-    def can_be_accessed_by_user(self, user_id: UserId) -> bool:
-        return self.user_id == user_id
-
-
-class Message(BaseModel):
-    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:
-        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:
-        return self.sender_type == SenderType.USER
-
-    def is_from_agent(self) -> bool:
-        return self.sender_type == SenderType.AGENT
-
-    def is_system_message(self) -> bool:
-        return self.sender_type == SenderType.SYSTEM
-
-
-class SessionHistory(BaseModel):
-    session: Session
-    messages: list[Message] = []
-    total_message_count: int = 0
-
-    def add_message(self, message: Message) -> None:
-        if message.session_id != self.session.id:
-            raise ValueError("Message does not belong to this session")
-
-        message.validate_message_content()
-        self.messages.append(message)
-        self.total_message_count += 1
-        self.session.mark_activity()
-
-    def get_messages_by_sender_type(self, sender_type: SenderType) -> list[Message]:
-        return [msg for msg in self.messages if msg.sender_type == sender_type]
-
-    def get_latest_messages(self, count: int = 10) -> list[Message]:
-        return sorted(self.messages, key=lambda x: x.created_at, reverse=True)[:count]

solace_agent_mesh/gateway/http_sse/domain/repositories/__init__.py

@@ -1,3 +0,0 @@
-from .session_repository import IMessageRepository, ISessionRepository
-
-__all__ = ["ISessionRepository", "IMessageRepository"]

solace_agent_mesh/gateway/http_sse/domain/repositories/session_repository.py

@@ -1,54 +0,0 @@
-from abc import ABC, abstractmethod
-
-from ...shared.types import PaginationInfo, SessionId, UserId
-from ..entities.session import Message, Session
-
-
-class ISessionRepository(ABC):
-    @abstractmethod
-    def get_by_id(self, session_id: SessionId) -> Session | None:
-        pass
-
-    @abstractmethod
-    def get_by_user_id(
-        self, user_id: UserId, pagination: PaginationInfo | None = None
-    ) -> list[Session]:
-        pass
-
-    @abstractmethod
-    def get_user_session(
-        self, session_id: SessionId, user_id: UserId
-    ) -> Session | None:
-        pass
-
-    @abstractmethod
-    def create(self, session: Session) -> Session:
-        pass
-
-    @abstractmethod
-    def update(self, session: Session) -> Session | None:
-        pass
-
-    @abstractmethod
-    def delete(self, session_id: SessionId, user_id: UserId) -> bool:
-        pass
-
-    @abstractmethod
-    def exists(self, session_id: SessionId) -> bool:
-        pass
-
-
-class IMessageRepository(ABC):
-    @abstractmethod
-    def get_by_session_id(
-        self, session_id: SessionId, pagination: PaginationInfo | None = None
-    ) -> list[Message]:
-        pass
-
-    @abstractmethod
-    def create(self, message: Message) -> Message:
-        pass
-
-    @abstractmethod
-    def delete_by_session_id(self, session_id: SessionId) -> bool:
-        pass

solace_agent_mesh/gateway/http_sse/infrastructure/__init__.py

@@ -1,4 +0,0 @@
-from .persistence.database_service import DatabaseService
-from .repositories.session_repository import SessionRepository, MessageRepository
-
-__all__ = ["DatabaseService", "SessionRepository", "MessageRepository"]

solace_agent_mesh/gateway/http_sse/infrastructure/dependency_injection/__init__.py

@@ -1,3 +0,0 @@
-from .container import ApplicationContainer, get_container, initialize_container
-
-__all__ = ["ApplicationContainer", "initialize_container", "get_container"]

solace_agent_mesh/gateway/http_sse/infrastructure/dependency_injection/container.py

@@ -1,123 +0,0 @@
-from collections.abc import Callable
-from typing import Any, TypeVar
-
-from ...application.services.session_service import SessionService
-from ...domain.repositories.session_repository import (
-    IMessageRepository,
-    ISessionRepository,
-)
-from ...infrastructure.persistence import database_service as db_service_module
-from ...infrastructure.persistence.database_service import DatabaseService
-from ...infrastructure.repositories.session_repository import (
-    MessageRepository,
-    SessionRepository,
-)
-
-T = TypeVar("T")
-
-
-class DIContainer:
-    """Dependency injection container."""
-
-    def __init__(self):
-        self._services: dict[str, Any] = {}
-        self._factories: dict[str, Callable] = {}
-        self._singletons: dict[str, Any] = {}
-
-    def register_singleton(self, service_type: type, instance: Any) -> None:
-        self._singletons[service_type.__name__] = instance
-
-    def register_factory(self, service_type: type, factory: Callable) -> None:
-        self._factories[service_type.__name__] = factory
-
-    def register_transient(self, service_type: type, implementation: type) -> None:
-        """Register a transient service (new instance each time)."""
-        self._services[service_type.__name__] = implementation
-
-    def get(self, service_type: type) -> Any:
-        """Get an instance of the requested service."""
-        service_name = service_type.__name__
-
-        # Check singletons first
-        if service_name in self._singletons:
-            return self._singletons[service_name]
-
-        # Check factories
-        if service_name in self._factories:
-            return self._factories[service_name]()
-
-        # Check transient services
-        if service_name in self._services:
-            implementation = self._services[service_name]
-            return self._create_instance(implementation)
-
-        raise ValueError(f"Service {service_name} is not registered")
-
-    def _create_instance(self, implementation: type) -> Any:
-        """Create an instance with dependency injection."""
-        # This is a simplified implementation
-        # In a production system, you'd use a more sophisticated approach
-        # like inspecting constructor parameters and resolving them automatically
-        return implementation()
-
-
-class ApplicationContainer:
-    """Application-specific dependency injection container."""
-
-    def __init__(self, database_url: str | None = None):
-        self.container = DIContainer()
-        self.database_url = database_url
-        self.has_database = database_url is not None
-        self._setup_dependencies()
-
-    def _setup_dependencies(self) -> None:
-        if self.has_database:
-            database_service = DatabaseService(self.database_url)
-            self.container.register_singleton(DatabaseService, database_service)
-            db_service_module.database_service = database_service
-
-            session_repository = SessionRepository(database_service)
-            message_repository = MessageRepository(database_service)
-
-            self.container.register_singleton(ISessionRepository, session_repository)
-            self.container.register_singleton(IMessageRepository, message_repository)
-
-            def session_service_factory():
-                return SessionService(session_repository, message_repository)
-
-            self.container.register_factory(SessionService, session_service_factory)
-
-    def get_database_service(self) -> DatabaseService | None:
-        if not self.has_database:
-            return None
-        return self.container.get(DatabaseService)
-
-    def get_session_service(self) -> SessionService | None:
-        if not self.has_database:
-            return None
-        return self.container.get(SessionService)
-
-
-# Global container instance
-_container: ApplicationContainer | None = None
-
-
-def initialize_container(database_url: str | None = None) -> ApplicationContainer:
-    global _container
-    _container = ApplicationContainer(database_url)
-
-    # Only create tables if database is available
-    if _container.has_database:
-        database_service = _container.get_database_service()
-        if database_service:
-            database_service.create_tables()
-
-    return _container
-
-
-def get_container() -> ApplicationContainer:
-    if _container is None:
-        raise RuntimeError(
-            "Container not initialized. Call initialize_container() first."
-        )
-    return _container

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/__init__.py

@@ -1,4 +0,0 @@
-from .database_service import DatabaseService
-from .models import Base, SessionModel, MessageModel
-
-__all__ = ["DatabaseService", "Base", "SessionModel", "MessageModel"]

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/database_persistence_service.py

@@ -1,16 +0,0 @@
-from sqlalchemy.orm import sessionmaker
-
-from .database_service import DatabaseService
-
-
-class DatabasePersistenceService:
-    def __init__(self, db_url: str):
-        self.db_service = DatabaseService(db_url)
-        self._session_factory = sessionmaker(bind=self.db_service.engine)
-
-    def Session(self):
-        return self._session_factory()
-
-    @property
-    def engine(self):
-        return self.db_service.engine

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/database_service.py

@@ -1,119 +0,0 @@
-import logging
-from collections.abc import Generator
-from contextlib import contextmanager
-
-from sqlalchemy import create_engine, event
-from sqlalchemy.orm import Session, sessionmaker
-
-from .models import Base
-
-
-def get_database_type(database_url: str) -> str:
-    """Get the database type from a database URL."""
-    if database_url.startswith("sqlite"):
-        return "sqlite"
-    elif database_url.startswith("postgresql"):
-        return "postgresql"
-    else:
-        return "unknown"
-
-
-class DatabaseService:
-    def __init__(self, database_url: str):
-        self.database_url = database_url
-        self.logger = logging.getLogger(__name__)
-
-        if database_url.startswith("sqlite"):
-            self._setup_sqlite_engine(database_url)
-        elif database_url.startswith("postgresql"):
-            self._setup_postgresql_engine(database_url)
-        else:
-            # Fallback for other databases
-            self._setup_generic_engine(database_url)
-
-        self.SessionLocal = sessionmaker(
-            autocommit=False, autoflush=False, bind=self.engine
-        )
-
-    def _setup_sqlite_engine(self, database_url: str):
-        """Configure SQLite-specific engine settings."""
-        self.engine = create_engine(
-            database_url,
-            echo=False,
-            connect_args={
-                "check_same_thread": False,
-            },
-        )
-
-        @event.listens_for(self.engine, "connect")
-        def set_sqlite_pragma(dbapi_connection, connection_record):
-            cursor = dbapi_connection.cursor()
-            cursor.execute("PRAGMA foreign_keys=ON")
-            cursor.close()
-
-    def _setup_postgresql_engine(self, database_url: str):
-        """Configure PostgreSQL-specific engine settings."""
-        try:
-            import psycopg2
-        except ImportError:
-            raise ImportError(
-                "PostgreSQL support requires psycopg2. Install with: "
-                "pip install 'solace-agent-mesh[postgresql]'"
-            )
-
-        self.engine = create_engine(
-            database_url,
-            pool_size=10,
-            max_overflow=20,
-            pool_timeout=30,
-            pool_recycle=3600,
-            pool_pre_ping=True,
-            echo=False,
-        )
-
-    def _setup_generic_engine(self, database_url: str):
-        """Configure generic database engine settings."""
-        self.engine = create_engine(
-            database_url,
-            pool_size=10,
-            max_overflow=20,
-            pool_timeout=30,
-            pool_recycle=3600,
-            pool_pre_ping=True,
-            echo=False,
-        )
-
-    def create_tables(self):
-        Base.metadata.create_all(bind=self.engine)
-
-    @contextmanager
-    def session_scope(self) -> Generator[Session, None, None]:
-        session = self.SessionLocal()
-        try:
-            yield session
-            session.commit()
-        except Exception as e:
-            session.rollback()
-            self.logger.error(f"Database transaction failed: {e}")
-            raise
-        finally:
-            session.close()
-
-    @contextmanager
-    def read_only_session(self) -> Generator[Session, None, None]:
-        session = self.SessionLocal()
-        try:
-            yield session
-        except Exception as e:
-            session.rollback()
-            self.logger.error(f"Database read operation failed: {e}")
-            raise
-        finally:
-            session.close()
-
-
-database_service: DatabaseService = None
-
-
-def get_database_service() -> DatabaseService:
-    return database_service

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/models.py

@@ -1,31 +0,0 @@
-from sqlalchemy import Column, DateTime, ForeignKey, String, Text
-from sqlalchemy.orm import declarative_base, relationship
-from sqlalchemy.sql import func
-
-Base = declarative_base()
-
-
-class SessionModel(Base):
-    __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())
-    messages = relationship(
-        "MessageModel", back_populates="session", cascade="all, delete-orphan"
-    )
-
-
-class MessageModel(Base):
-    __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))
-    session = relationship("SessionModel", back_populates="messages")

solace_agent_mesh/gateway/http_sse/infrastructure/persistence_service.py

@@ -1,12 +0,0 @@
-from .dependency_injection.container import ApplicationContainer
-from .persistence.database_service import DatabaseService
-
-
-class PersistenceService:
-    def __init__(self, database_url: str):
-        self.db_service = DatabaseService(database_url)
-        self.container = ApplicationContainer(database_url)
-
-    @property
-    def engine(self):
-        return self.db_service.engine

solace_agent_mesh/gateway/http_sse/infrastructure/repositories/__init__.py

@@ -1,3 +0,0 @@
-from .session_repository import SessionRepository, MessageRepository
-
-__all__ = ["SessionRepository", "MessageRepository"]

solace_agent_mesh/gateway/http_sse/infrastructure/repositories/session_repository.py

@@ -1,174 +0,0 @@
-from ...domain.entities.session import Message, Session
-from ...domain.repositories.session_repository import (
-    IMessageRepository,
-    ISessionRepository,
-)
-from ...shared.enums import SenderType, SessionStatus
-from ...shared.types import PaginationInfo, SessionId, UserId
-from ..persistence.database_service import DatabaseService
-from ..persistence.models import MessageModel, SessionModel
-
-
-class SessionRepository(ISessionRepository):
-    def __init__(self, db_service: DatabaseService):
-        self.db_service = db_service
-
-    def get_by_id(self, session_id: SessionId) -> Session | None:
-        with self.db_service.read_only_session() as session:
-            model = (
-                session.query(SessionModel)
-                .filter(SessionModel.id == session_id)
-                .first()
-            )
-            return self._model_to_entity(model) if model else None
-
-    def get_by_user_id(
-        self, user_id: UserId, pagination: PaginationInfo | None = None
-    ) -> list[Session]:
-        with self.db_service.read_only_session() as session:
-            query = session.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 get_user_session(
-        self, session_id: SessionId, user_id: UserId
-    ) -> Session | None:
-        with self.db_service.read_only_session() as session:
-            model = (
-                session.query(SessionModel)
-                .filter(SessionModel.id == session_id, SessionModel.user_id == user_id)
-                .first()
-            )
-            return self._model_to_entity(model) if model else None
-
-    def create(self, session_entity: Session) -> Session:
-        with self.db_service.session_scope() as session:
-            model = SessionModel(
-                id=session_entity.id,
-                user_id=session_entity.user_id,
-                name=session_entity.name,
-                agent_id=session_entity.agent_id,
-                created_at=session_entity.created_at,
-                updated_at=session_entity.updated_at,
-            )
-            session.add(model)
-            session.flush()
-            session.refresh(model)
-            return self._model_to_entity(model)
-
-    def update(self, session_entity: Session) -> Session | None:
-        with self.db_service.session_scope() as session:
-            model = (
-                session.query(SessionModel)
-                .filter(
-                    SessionModel.id == session_entity.id,
-                    SessionModel.user_id == session_entity.user_id,
-                )
-                .first()
-            )
-
-            if not model:
-                return None
-
-            model.name = session_entity.name
-            model.agent_id = session_entity.agent_id
-            model.updated_at = session_entity.updated_at
-
-            session.flush()
-            session.refresh(model)
-            return self._model_to_entity(model)
-
-    def delete(self, session_id: SessionId, user_id: UserId) -> bool:
-        with self.db_service.session_scope() as session:
-            model = (
-                session.query(SessionModel)
-                .filter(SessionModel.id == session_id, SessionModel.user_id == user_id)
-                .first()
-            )
-
-            if not model:
-                return False
-
-            session.delete(model)
-            return True
-
-    def exists(self, session_id: SessionId) -> bool:
-        with self.db_service.read_only_session() as session:
-            return (
-                session.query(SessionModel)
-                .filter(SessionModel.id == session_id)
-                .first()
-                is not None
-            )
-
-    def _model_to_entity(self, model: SessionModel) -> Session:
-        return Session(
-            id=model.id,
-            user_id=model.user_id,
-            name=model.name,
-            agent_id=model.agent_id,
-            status=SessionStatus.ACTIVE,
-            created_at=model.created_at,
-            updated_at=model.updated_at,
-            last_activity=model.updated_at,
-        )
-
-
-class MessageRepository(IMessageRepository):
-    def __init__(self, db_service: DatabaseService):
-        self.db_service = db_service
-
-    def get_by_session_id(
-        self, session_id: SessionId, pagination: PaginationInfo | None = None
-    ) -> list[Message]:
-        with self.db_service.read_only_session() as session:
-            query = session.query(MessageModel).filter(
-                MessageModel.session_id == session_id
-            )
-            query = query.order_by(MessageModel.created_at.asc())
-
-            if pagination:
-                offset = (pagination.page - 1) * pagination.page_size
-                query = query.offset(offset).limit(pagination.page_size)
-
-            models = query.all()
-            return [self._model_to_entity(model) for model in models]
-
-    def create(self, message_entity: Message) -> Message:
-        with self.db_service.session_scope() as session:
-            model = MessageModel(
-                id=message_entity.id,
-                session_id=message_entity.session_id,
-                message=message_entity.message,
-                sender_type=message_entity.sender_type.value,
-                sender_name=message_entity.sender_name,
-                created_at=message_entity.created_at,
-            )
-            session.add(model)
-            session.flush()
-            session.refresh(model)
-            return self._model_to_entity(model)
-
-    def delete_by_session_id(self, session_id: SessionId) -> bool:
-        with self.db_service.session_scope() as session:
-            deleted_count = (
-                session.query(MessageModel)
-                .filter(MessageModel.session_id == session_id)
-                .delete()
-            )
-            return deleted_count > 0
-
-    def _model_to_entity(self, model: MessageModel) -> Message:
-        return Message(
-            id=model.id,
-            session_id=model.session_id,
-            message=model.message,
-            sender_type=SenderType(model.sender_type),
-            sender_name=model.sender_name,
-            created_at=model.created_at,
-        )