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

solace_agent_mesh/gateway/http_sse/alembic/versions/20250916_f6e7d8c9b0a1_convert_timestamps_to_epoch_and_align_columns.py

@@ -104,22 +104,38 @@ def _upgrade_sqlite(current_time_ms: int) -> None:
 def _upgrade_standard_sql(current_time_ms: int) -> None:
     """Handle PostgreSQL/MySQL upgrade using ALTER COLUMN (standard SQL approach)."""
 
+    bind = op.get_bind()
+
     # For sessions table
     op.add_column("sessions", sa.Column("created_time", sa.BigInteger(), nullable=True))
     op.add_column("sessions", sa.Column("updated_time", sa.BigInteger(), nullable=True))
 
-    # Convert timestamps using EXTRACT function
-    op.execute("""
-        UPDATE sessions
-        SET created_time = CAST(EXTRACT(EPOCH FROM created_at) * 1000 AS BIGINT)
-        WHERE created_at IS NOT NULL
-    """)
-
-    op.execute("""
-        UPDATE sessions
-        SET updated_time = CAST(EXTRACT(EPOCH FROM updated_at) * 1000 AS BIGINT)
-        WHERE updated_at IS NOT NULL
-    """)
+    # Convert timestamps using database-appropriate functions
+    if bind.dialect.name == 'postgresql':
+        op.execute("""
+            UPDATE sessions
+            SET created_time = CAST(EXTRACT(EPOCH FROM created_at) * 1000 AS BIGINT)
+            WHERE created_at IS NOT NULL
+        """)
+
+        op.execute("""
+            UPDATE sessions
+            SET updated_time = CAST(EXTRACT(EPOCH FROM updated_at) * 1000 AS BIGINT)
+            WHERE updated_at IS NOT NULL
+        """)
+    else:
+        # MySQL and other databases use UNIX_TIMESTAMP
+        op.execute("""
+            UPDATE sessions
+            SET created_time = CAST(UNIX_TIMESTAMP(created_at) * 1000 AS UNSIGNED)
+            WHERE created_at IS NOT NULL
+        """)
+
+        op.execute("""
+            UPDATE sessions
+            SET updated_time = CAST(UNIX_TIMESTAMP(updated_at) * 1000 AS UNSIGNED)
+            WHERE updated_at IS NOT NULL
+        """)
 
     # Set current epoch ms for null values
     op.execute(f"""
@@ -145,11 +161,19 @@ def _upgrade_standard_sql(current_time_ms: int) -> None:
     # For chat_messages table
     op.add_column("chat_messages", sa.Column("created_time", sa.BigInteger(), nullable=True))
 
-    op.execute("""
-        UPDATE chat_messages
-        SET created_time = CAST(EXTRACT(EPOCH FROM created_at) * 1000 AS BIGINT)
-        WHERE created_at IS NOT NULL
-    """)
+    if bind.dialect.name == 'postgresql':
+        op.execute("""
+            UPDATE chat_messages
+            SET created_time = CAST(EXTRACT(EPOCH FROM created_at) * 1000 AS BIGINT)
+            WHERE created_at IS NOT NULL
+        """)
+    else:
+        # MySQL and other databases use UNIX_TIMESTAMP
+        op.execute("""
+            UPDATE chat_messages
+            SET created_time = CAST(UNIX_TIMESTAMP(created_at) * 1000 AS UNSIGNED)
+            WHERE created_at IS NOT NULL
+        """)
 
     op.execute(f"""
         UPDATE chat_messages
@@ -199,18 +223,41 @@ def _create_updated_indexes() -> None:
 
 def _create_indexes_safe(index_name: str, table_name: str, columns: list) -> None:
     """Create index only if it doesn't exist."""
-    try:
-        op.create_index(index_name, table_name, columns)
-    except Exception:
-        pass  # Index might already exist
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    if bind.dialect.name == 'postgresql':
+        columns_str = ', '.join(columns)
+        bind.execute(sa.text(f"CREATE INDEX IF NOT EXISTS {index_name} ON {table_name} ({columns_str})"))
+    elif bind.dialect.name == 'sqlite':
+        try:
+            op.create_index(index_name, table_name, columns)
+        except Exception:
+            pass
+    else:
+        existing_indexes = inspector.get_indexes(table_name)
+        index_exists = any(idx['name'] == index_name for idx in existing_indexes)
+        if not index_exists:
+            op.create_index(index_name, table_name, columns)
 
 
 def _drop_index_safe(index_name: str, table_name: str) -> None:
     """Drop index only if it exists."""
-    try:
-        op.drop_index(index_name, table_name=table_name)
-    except Exception:
-        pass  # Index might not exist
+    bind = op.get_bind()
+    inspector = sa.inspect(bind)
+
+    if bind.dialect.name == 'postgresql':
+        bind.execute(sa.text(f"DROP INDEX IF EXISTS {index_name}"))
+    elif bind.dialect.name == 'sqlite':
+        try:
+            op.drop_index(index_name, table_name=table_name)
+        except Exception:
+            pass
+    else:
+        existing_indexes = inspector.get_indexes(table_name)
+        index_exists = any(idx['name'] == index_name for idx in existing_indexes)
+        if index_exists:
+            op.drop_index(index_name, table_name=table_name)
 
 
 def downgrade() -> None:
@@ -297,6 +344,7 @@ def _downgrade_sqlite() -> None:
 
 def _downgrade_standard_sql() -> None:
     """Handle PostgreSQL/MySQL downgrade using ALTER COLUMN."""
+    bind = op.get_bind()
 
     # Drop indexes on new columns
     _drop_index_safe("ix_chat_messages_session_id_created_time", "chat_messages")
@@ -308,18 +356,32 @@ def _downgrade_standard_sql() -> None:
     op.add_column("sessions", sa.Column("created_at", sa.DateTime(), nullable=True))
     op.add_column("sessions", sa.Column("updated_at", sa.DateTime(), nullable=True))
 
-    # Convert epoch milliseconds back to datetime
-    op.execute("""
-        UPDATE sessions
-        SET created_at = to_timestamp(created_time / 1000.0)
-        WHERE created_time IS NOT NULL
-    """)
-
-    op.execute("""
-        UPDATE sessions
-        SET updated_at = to_timestamp(updated_time / 1000.0)
-        WHERE updated_time IS NOT NULL
-    """)
+    # Convert epoch milliseconds back to datetime based on database type
+    if bind.dialect.name == 'postgresql':
+        op.execute("""
+            UPDATE sessions
+            SET created_at = to_timestamp(created_time / 1000.0)
+            WHERE created_time IS NOT NULL
+        """)
+
+        op.execute("""
+            UPDATE sessions
+            SET updated_at = to_timestamp(updated_time / 1000.0)
+            WHERE updated_time IS NOT NULL
+        """)
+    else:
+        # MySQL and other databases
+        op.execute("""
+            UPDATE sessions
+            SET created_at = FROM_UNIXTIME(created_time / 1000.0)
+            WHERE created_time IS NOT NULL
+        """)
+
+        op.execute("""
+            UPDATE sessions
+            SET updated_at = FROM_UNIXTIME(updated_time / 1000.0)
+            WHERE updated_time IS NOT NULL
+        """)
 
     op.drop_column("sessions", "created_time")
     op.drop_column("sessions", "updated_time")
@@ -327,11 +389,19 @@ def _downgrade_standard_sql() -> None:
     # For chat_messages table: convert back to datetime column
     op.add_column("chat_messages", sa.Column("created_at", sa.DateTime(), nullable=True))
 
-    op.execute("""
-        UPDATE chat_messages
-        SET created_at = to_timestamp(created_time / 1000.0)
-        WHERE created_time IS NOT NULL
-    """)
+    if bind.dialect.name == 'postgresql':
+        op.execute("""
+            UPDATE chat_messages
+            SET created_at = to_timestamp(created_time / 1000.0)
+            WHERE created_time IS NOT NULL
+        """)
+    else:
+        # MySQL and other databases
+        op.execute("""
+            UPDATE chat_messages
+            SET created_at = FROM_UNIXTIME(created_time / 1000.0)
+            WHERE created_time IS NOT NULL
+        """)
 
     op.drop_column("chat_messages", "created_time")
 

solace_agent_mesh/gateway/http_sse/app.py

@@ -4,9 +4,6 @@ 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
@@ -188,31 +185,6 @@ class WebUIBackendApp(BaseGatewayApp):
         )
         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)
 

solace_agent_mesh/gateway/http_sse/component.py

@@ -1690,23 +1690,29 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                 message_text += part.text
 
                     if message_text and session_id and user_id:
-                        from .dependencies import (
-                            create_session_service_with_transaction,
-                        )
+                        from .dependencies import SessionLocal, get_session_business_service
                         from ...gateway.http_sse.shared.enums import SenderType
 
-                        with create_session_service_with_transaction() as (
-                            session_service,
-                            db,
-                        ):
-                            session_service.add_message_to_session(
-                                session_id=session_id,
-                                user_id=user_id,
-                                message=message_text,
-                                sender_type=SenderType.AGENT,
-                                sender_name=agent_name,
-                                agent_id=agent_name,
-                            )
+                        # For background processing, create simple session wrapper
+                        if SessionLocal:
+                            db = SessionLocal()
+                            try:
+                                session_service = get_session_business_service()
+                                session_service.add_message_to_session(
+                                    db=db,
+                                    session_id=session_id,
+                                    user_id=user_id,
+                                    message=message_text,
+                                    sender_type=SenderType.AGENT,
+                                    sender_name=agent_name,
+                                    agent_id=agent_name,
+                                )
+                                db.commit()
+                            except Exception:
+                                db.rollback()
+                                raise
+                            finally:
+                                db.close()
                         log.info(
                             "%s Final agent response stored in session %s",
                             log_id_prefix,

solace_agent_mesh/gateway/http_sse/dependencies.py

@@ -273,6 +273,54 @@ async def get_user_config(
     )
 
 
+class ValidatedUserConfig:
+    """
+    FastAPI dependency class for validating user scopes and returning user config.
+
+    This class creates a callable dependency that validates a user has the required
+    scopes before allowing access to protected endpoints.
+
+    Args:
+        required_scopes: List of scope strings required for authorization
+
+    Raises:
+        HTTPException: 403 if user lacks required scopes
+
+    Example:
+        @router.get("/artifacts")
+        async def list_artifacts(
+            user_config: dict = Depends(ValidatedUserConfig(["tool:artifact:list"])),
+        ):
+    """
+
+    def __init__(self, required_scopes: list[str]):
+        self.required_scopes = required_scopes
+
+    async def __call__(
+        self,
+        request: Request,
+        config_resolver: ConfigResolver = Depends(get_config_resolver),
+        user_config: dict[str, Any] = Depends(get_user_config),
+    ) -> dict[str, Any]:
+        user_id = user_config.get("user_profile", {}).get("id")
+
+        log.debug(f"[Dependencies] ValidatedUserConfig called for user_id: {user_id} with required scopes: {self.required_scopes}")
+
+        # Validate scopes
+        if not config_resolver.is_feature_enabled(
+                user_config, {"tool_metadata": {"required_scopes": self.required_scopes}}, {}
+        ):
+            log.warning(
+                f"[Dependencies] Authorization denied for user '{user_id}'. Required scopes: {self.required_scopes}"
+            )
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f"Not authorized. Required scopes: {self.required_scopes}"
+            )
+
+        return user_config
+
+
 def get_shared_artifact_service(
     component: "WebUIBackendComponent" = Depends(get_sac_component),
 ) -> BaseArtifactService | None:
@@ -366,98 +414,15 @@ def get_db() -> Generator[Session, None, None]:
 
 
 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)
-
+    # Note: Session and message repositories will be created per request
+    # when the SessionService methods receive the db parameter
+    return SessionService(component=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 .shared.enums import MessageType
-                from .shared import now_epoch_ms
-
-                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_time=now_epoch_ms(),
-                )
-                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 .repository.entities import Session
-                from .shared import now_epoch_ms
-
-                if not session_id:
-                    session_id = str(uuid4())
-
-                # Leave name as None/empty - frontend will generate display name if needed
-
-                now_ms = now_epoch_ms()
-                session = Session(
-                    id=session_id,
-                    user_id=user_id,
-                    name=name,
-                    agent_id=agent_id,
-                    created_time=now_ms,
-                    updated_time=now_ms,
-                )
-
-                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(
@@ -470,9 +435,13 @@ def get_session_validator(
 
         def validate_with_database(session_id: str, user_id: str) -> bool:
             try:
-                with create_session_service_with_transaction() as (session_service, db):
-                    session_domain = session_service.get_session(session_id, user_id)
+                db = SessionLocal()
+                try:
+                    session_repository = SessionRepository(db)
+                    session_domain = session_repository.find_user_session(session_id, user_id)
                     return session_domain is not None
+                finally:
+                    db.close()
             except:
                 return False
 
@@ -486,3 +455,30 @@ def get_session_validator(
             return bool(user_id)
 
         return validate_without_database
+
+
+def get_db_optional() -> Generator[Session | None, None, None]:
+    """Optional database dependency that returns None if database is not configured."""
+    if SessionLocal is None:
+        log.debug("[Dependencies] Database not configured, returning None")
+        yield None
+    else:
+        db = SessionLocal()
+        try:
+            yield db
+            db.commit()
+        except Exception:
+            db.rollback()
+            raise
+        finally:
+            db.close()
+
+
+def get_session_business_service_optional(
+    component: "WebUIBackendComponent" = Depends(get_sac_component),
+) -> SessionService | None:
+    """Optional session service dependency that returns None if database is not configured."""
+    if SessionLocal is None:
+        log.debug("[Dependencies] Database not configured, returning None for session service")
+        return None
+    return SessionService(component=component)

solace_agent_mesh/gateway/http_sse/main.py

@@ -310,38 +310,48 @@ def _setup_alembic_config(database_url: str) -> Config:
 
 
 def _run_community_migrations(database_url: str) -> None:
+    """
+    Run Alembic migrations for the community database schema.
+    This includes sessions, chat_messages tables and their indexes.
+    """
     try:
         from sqlalchemy import create_engine
 
+        log.info("Starting community migrations...")
         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:
-            log.info("Running community database migrations...")
+            log.info("Running initial community database setup")
             alembic_cfg = _setup_alembic_config(database_url)
             command.upgrade(alembic_cfg, "head")
-            log.info("Community database migrations complete.")
+            log.info("Community database migrations completed")
         else:
-            log.info(
-                "Community database tables already exist, skipping community migrations."
-            )
+            log.info("Checking for community schema updates")
+            alembic_cfg = _setup_alembic_config(database_url)
+            command.upgrade(alembic_cfg, "head")
+            log.info("Community database schema is current")
     except Exception as e:
         log.warning(
-            "Community migration check failed, attempting to run migrations anyway: %s",
+            "Community migration check failed: %s - attempting to run migrations",
             e,
         )
         try:
             alembic_cfg = _setup_alembic_config(database_url)
             command.upgrade(alembic_cfg, "head")
-            log.info("Community database migrations complete.")
+            log.info("Community database migrations completed")
         except Exception as migration_error:
-            log.warning(
-                "Community migration failed but continuing: %s", migration_error
-            )
+            log.error("Community migration failed: %s", migration_error)
+            log.error("Check database connectivity and permissions")
+            raise RuntimeError(f"Community database migration failed: {migration_error}") from migration_error
 
 
 def _run_enterprise_migrations(component: "WebUIBackendComponent", database_url: str) -> None:
+    """
+    Run migrations for enterprise features like advanced analytics, audit logs, etc.
+    This is optional and only runs if the enterprise package is available.
+    """
     try:
         from solace_agent_mesh_enterprise.webui_backend.migration_runner import (
             run_migrations,
@@ -349,19 +359,25 @@ def _run_enterprise_migrations(component: "WebUIBackendComponent", database_url:
 
         webui_app = component.get_app()
         app_config = getattr(webui_app, "app_config", {}) if webui_app else {}
-        log.info("Running enterprise migrations...")
+        log.info("Starting enterprise migrations...")
         run_migrations(database_url, app_config)
         log.info("Enterprise migrations completed")
     except (ImportError, ModuleNotFoundError):
         log.debug("Enterprise module not found - skipping enterprise migrations")
     except Exception as e:
-        log.warning("Enterprise migration failed but continuing: %s", e)
+        log.error("Enterprise migration failed: %s", e)
+        log.error("Advanced features may be unavailable")
+        raise RuntimeError(f"Enterprise database migration failed: {e}") from e
 
 
 def _setup_database(component: "WebUIBackendComponent", database_url: str) -> None:
+    """
+    Initialize database connection and run all required migrations.
+    This sets up both community and enterprise database schemas.
+    """
     dependencies.init_database(database_url)
     log.info("Persistence enabled - sessions will be stored in database")
-    log.info("Checking database migrations...")
+    log.info("Running database migrations...")
 
     _run_community_migrations(database_url)
     _run_enterprise_migrations(component, database_url)
@@ -463,6 +479,12 @@ def _setup_routers() -> None:
     app.include_router(auth.router, prefix=api_prefix, tags=["Auth"])
     log.info("Legacy routers mounted for endpoints not yet migrated")
 
+    # Register shared exception handlers from community repo
+    from .shared.exception_handlers import register_exception_handlers
+    register_exception_handlers(app)
+    log.info("Registered shared exception handlers from community repo")
+
+    # Mount enterprise routers if available
     try:
         from solace_agent_mesh_enterprise.webui_backend.routers import get_enterprise_routers
 
@@ -478,9 +500,9 @@ def _setup_routers() -> None:
     except ImportError:
         log.debug("No enterprise package detected - skipping enterprise routers")
     except ModuleNotFoundError:
-        log.debug("Enterprise router module not found - skipping enterprise routers")
+        log.debug("Enterprise module not found - skipping enterprise routers and exception handlers")
     except Exception as e:
-        log.warning("Failed to load enterprise routers: %s", e)
+        log.warning("Failed to load enterprise routers and exception handlers: %s", e)
 
 
 def _setup_static_files() -> None:

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

@@ -2,7 +2,7 @@
 Message domain entity.
 """
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from ...shared.enums import MessageType, SenderType
 from ...shared.types import MessageId, SessionId
@@ -11,6 +11,8 @@ from ...shared.types import MessageId, SessionId
 class Message(BaseModel):
     """Message domain entity with business logic."""
 
+    model_config = ConfigDict(from_attributes=True)
+
     id: MessageId
     session_id: SessionId
     message: str

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

@@ -2,7 +2,7 @@
 Session domain entity.
 """
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
 
 from ...shared import now_epoch_ms
 from ...shared.types import AgentId, SessionId, UserId
@@ -11,6 +11,8 @@ from ...shared.types import AgentId, SessionId, UserId
 class Session(BaseModel):
     """Session domain entity with business logic."""
 
+    model_config = ConfigDict(from_attributes=True)
+
     id: SessionId
     user_id: UserId
     name: str | None = None

solace_agent_mesh/gateway/http_sse/repository/interfaces.py

@@ -18,6 +18,11 @@ class ISessionRepository(ABC):
         """Find all sessions for a specific user."""
         pass
 
+    @abstractmethod
+    def count_by_user(self, user_id: UserId) -> int:
+        """Count total sessions for a specific user."""
+        pass
+
     @abstractmethod
     def find_user_session(
         self, session_id: SessionId, user_id: UserId