solace-agent-mesh 1.11.2__py3-none-any.whl

solace_agent_mesh/services/platform/__init__.py

@@ -0,0 +1,18 @@
+"""
+Platform Service for Solace Agent Mesh.
+
+Provides REST API for platform configuration management:
+- Agents
+- Connectors
+- Toolsets
+- Deployments
+- AI Assistant
+
+This service is NOT a gateway - it does not:
+- Manage chat sessions
+- Submit tasks to agents via A2A
+- Handle artifacts or embeds
+- Communicate with the agent mesh
+
+It only validates OAuth2 tokens and performs CRUD operations on platform data.
+"""

solace_agent_mesh/services/platform/alembic/env.py

@@ -0,0 +1,85 @@
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+from sqlalchemy.ext.declarative import declarative_base
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Create a placeholder Base for future community platform models
+# When community models are added, import them here to ensure they are registered
+Base = declarative_base()
+
+# Import all models here to ensure they are registered with the Base
+# Example:
+# from solace_agent_mesh.services.platform.models.example_model import ExampleModel
+
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+SQLALCHEMY_URL_KEY = "sqlalchemy.url"
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option(SQLALCHEMY_URL_KEY)
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    # Get the database URL from the Alembic config
+    url = config.get_main_option(SQLALCHEMY_URL_KEY)
+    if not url:
+        raise ValueError(
+            f"Database URL is not set. Please set {SQLALCHEMY_URL_KEY} in alembic.ini or via command line."
+        )
+
+    # Create a configuration dictionary for the engine
+    # This ensures that the URL is correctly picked up by engine_from_config
+    engine_config = {SQLALCHEMY_URL_KEY: url}
+
+    connectable = engine_from_config(
+        engine_config,
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

solace_agent_mesh/services/platform/alembic/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

solace_agent_mesh/services/platform/alembic.ini

@@ -0,0 +1,109 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts.
+# this is typically a path given in POSIX (e.g. forward slashes)
+# format, relative to the token %(here)s which refers to the location of this
+# ini file
+script_location = %(here)s/alembic
+
+# Template used to generate migration file names
+# Format: YYYYMMDD_revision_description
+file_template = %%(year)d%%(month).2d%%(day).2d_%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.  for multiple paths, the path separator
+# is defined by "path_separator" below.
+prepend_sys_path = .
+
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to <script_location>/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "path_separator"
+# below.
+# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
+
+# path_separator; This indicates what character is used to split lists of file
+# paths, including version_locations and prepend_sys_path within configparser
+# files such as alembic.ini.
+# The default rendered in new alembic.ini files is "os", which uses os.pathsep
+# to provide os-dependent path splitting.
+#
+# Note that in order to support legacy alembic.ini files, this default does NOT
+# take place if path_separator is not present in alembic.ini.  If this
+# option is omitted entirely, fallback logic is as follows:
+#
+# 1. Parsing of the version_locations option falls back to using the legacy
+#    "version_path_separator" key, which if absent then falls back to the legacy
+#    behavior of splitting on spaces and/or commas.
+# 2. Parsing of the prepend_sys_path option falls back to the legacy
+#    behavior of splitting on spaces, commas, or colons.
+#
+# Valid values for path_separator are:
+#
+# path_separator = :
+# path_separator = ;
+# path_separator = space
+# path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# database URL.  This is consumed by the user-maintained env.py script only.
+# other means of configuring database URLs may be customized within the env.py
+# file.
+# sqlalchemy.url = sqlite:////Users/mradwan/solace_agent_mesh.db
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module
+# hooks = ruff
+# ruff.type = module
+# ruff.module = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Alternatively, use the exec runner to execute a binary found on your PATH
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME

solace_agent_mesh/services/platform/api/__init__.py

@@ -0,0 +1,3 @@
+"""
+Platform Service FastAPI application and supporting modules.
+"""

solace_agent_mesh/services/platform/api/dependencies.py

@@ -0,0 +1,147 @@
+"""
+FastAPI dependency injection for Platform Service.
+
+Provides database sessions, component instance access, and user authentication.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Generator
+
+from fastapi import HTTPException, Request, status
+from sqlalchemy import create_engine, event, pool
+from sqlalchemy.engine.url import make_url
+from sqlalchemy.orm import Session, sessionmaker
+
+if TYPE_CHECKING:
+    from ..component import PlatformServiceComponent
+
+log = logging.getLogger(__name__)
+
+# Global state
+platform_component_instance: "PlatformServiceComponent" = None
+PlatformSessionLocal: sessionmaker = None
+
+
+def set_component_instance(component: "PlatformServiceComponent"):
+    """
+    Store the component reference for dependency injection.
+
+    Called by setup_dependencies during component startup.
+
+    Args:
+        component: The PlatformServiceComponent instance.
+    """
+    global platform_component_instance
+    if platform_component_instance is None:
+        platform_component_instance = component
+        log.info("Platform component instance provided.")
+    else:
+        log.warning("Platform component instance already set.")
+
+
+def init_database(database_url: str):
+    """
+    Initialize database connection with dialect-specific configuration.
+
+    Configures appropriate connection pooling and settings for:
+    - SQLite: StaticPool, foreign key enforcement
+    - PostgreSQL/MySQL: Connection pooling with pre-ping
+
+    Args:
+        database_url: SQLAlchemy database URL string.
+    """
+    global PlatformSessionLocal
+    if PlatformSessionLocal is None:
+        url = make_url(database_url)
+        dialect_name = url.get_dialect().name
+
+        engine_kwargs = {}
+
+        if dialect_name == "sqlite":
+            engine_kwargs = {
+                "poolclass": pool.StaticPool,
+                "connect_args": {"check_same_thread": False},
+            }
+            log.info("Configuring SQLite database (single-connection mode)")
+
+        elif dialect_name in ("postgresql", "mysql"):
+            engine_kwargs = {
+                "pool_size": 10,
+                "max_overflow": 20,
+                "pool_timeout": 30,
+                "pool_recycle": 1800,
+                "pool_pre_ping": True,
+            }
+            log.info(f"Configuring {dialect_name} database with connection pooling")
+
+        else:
+            log.warning(f"Using default configuration for dialect: {dialect_name}")
+
+        engine = create_engine(database_url, **engine_kwargs)
+
+        @event.listens_for(engine, "connect")
+        def set_sqlite_pragma(dbapi_conn, connection_record):
+            """Enable foreign key constraints for SQLite."""
+            if dialect_name == "sqlite":
+                cursor = dbapi_conn.cursor()
+                cursor.execute("PRAGMA foreign_keys=ON")
+                cursor.close()
+
+        PlatformSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        log.info("Database initialized successfully")
+    else:
+        log.warning("Database already initialized.")
+
+
+def get_platform_db() -> Generator[Session, None, None]:
+    """
+    FastAPI dependency for platform database session management.
+
+    Provides a database session with automatic commit/rollback:
+    - Commits on success
+    - Rolls back on exception
+    - Always closes the session
+
+    Yields:
+        SQLAlchemy database session for platform database.
+
+    Raises:
+        HTTPException: 503 if database is not initialized.
+    """
+    if PlatformSessionLocal is None:
+        raise HTTPException(
+            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+            detail="Database not initialized.",
+        )
+    db = PlatformSessionLocal()
+    try:
+        yield db
+        db.commit()
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()
+
+
+def get_current_user(request: Request) -> dict:
+    """
+    FastAPI dependency to extract authenticated user from request state.
+
+    The user is set by the OAuth2 middleware during request processing.
+
+    Args:
+        request: FastAPI Request object.
+
+    Returns:
+        Dictionary containing user information (user_id, email, name, etc.).
+
+    Raises:
+        HTTPException: 401 if user is not authenticated.
+    """
+    if not hasattr(request.state, "user") or not request.state.user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authentication required",
+        )
+    return request.state.user

solace_agent_mesh/services/platform/api/main.py

@@ -0,0 +1,280 @@
+"""
+FastAPI application for Platform Service.
+"""
+
+import logging
+import os
+from typing import TYPE_CHECKING
+
+import sqlalchemy as sa
+from alembic import command
+from alembic.config import Config
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+if TYPE_CHECKING:
+    from ..component import PlatformServiceComponent
+
+log = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="Platform Service API",
+    version="1.0.0",
+    description="Platform configuration management API (agents, connectors, toolsets, deployments)",
+)
+
+# Global flag to track initialization (idempotent)
+_dependencies_initialized = False
+
+
+def _setup_alembic_config(database_url: str) -> Config:
+    """
+    Create and configure an Alembic Config object for community platform migrations.
+
+    Args:
+        database_url: Database connection string.
+
+    Returns:
+        Configured Alembic Config object.
+    """
+    alembic_cfg = Config()
+    # Note: __file__ is in api/main.py, so we go up one level (..) to get to platform/
+    alembic_cfg.set_main_option(
+        "script_location",
+        os.path.join(os.path.dirname(__file__), "..", "alembic"),
+    )
+    alembic_cfg.set_main_option("sqlalchemy.url", database_url)
+    return alembic_cfg
+
+
+def _run_community_migrations(database_url: str) -> None:
+    """
+    Run Alembic migrations for the community platform database schema.
+    This includes any base tables defined in the community repo.
+
+    Args:
+        database_url: Database connection string.
+    """
+    try:
+        from sqlalchemy import create_engine
+
+        log.info("Starting community platform migrations...")
+        engine = create_engine(database_url)
+        inspector = sa.inspect(engine)
+        existing_tables = inspector.get_table_names()
+
+        if not existing_tables:
+            log.info("Running initial community platform database setup")
+            alembic_cfg = _setup_alembic_config(database_url)
+            command.upgrade(alembic_cfg, "head")
+            log.info("Community platform database migrations completed")
+        else:
+            log.info("Checking for community platform schema updates")
+            alembic_cfg = _setup_alembic_config(database_url)
+            command.upgrade(alembic_cfg, "head")
+            log.info("Community platform database schema is current")
+    except Exception as e:
+        log.warning(
+            "Community platform 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 platform database migrations completed")
+        except Exception as migration_error:
+            log.error("Community platform migration failed: %s", migration_error)
+            log.error("Check database connectivity and permissions")
+            raise RuntimeError(
+                f"Community platform database migration failed: {migration_error}"
+            ) from migration_error
+
+
+def _run_enterprise_migrations(database_url: str) -> None:
+    """
+    Run migrations for enterprise platform features.
+    This is optional and only runs if the enterprise package is available.
+
+    Args:
+        component: PlatformServiceComponent instance.
+        database_url: Database connection string.
+    """
+    try:
+        from solace_agent_mesh_enterprise.webui_backend.migration_runner import run_migrations
+
+        log.info("Starting enterprise platform migrations...")
+        run_migrations(database_url)
+        log.info("Enterprise platform migrations completed")
+    except ImportError:
+        log.debug("Enterprise platform module not found - skipping enterprise migrations")
+    except Exception as e:
+        log.error("Enterprise platform migration failed: %s", e)
+        log.error("Enterprise platform features may be unavailable")
+        raise RuntimeError(f"Enterprise platform database migration failed: {e}") from e
+
+
+def _setup_database(database_url: str) -> None:
+    """
+    Initialize database connection and run all required migrations.
+    Sets up both community and enterprise platform database schemas.
+
+    This follows the same pattern as gateway/http_sse:
+    1. Initialize database (create engine and SessionLocal)
+    2. Run community migrations
+    3. Run enterprise migrations (if available)
+
+    Args:
+        component: PlatformServiceComponent instance.
+        database_url: Platform database URL (agents, connectors, deployments, toolsets) - REQUIRED
+    """
+    from . import dependencies
+
+    # MIGRATION PHASE 1: DB is initialized in enterprise repo. In next phase, platform db will be initialized here
+    # dependencies.init_database(database_url)
+    # log.info("Platform database initialized - running migrations...")
+
+    # MIGRATION PHASE 1: No community migrations yet - only enterprise migrations
+    # _run_community_migrations(database_url)
+    _run_enterprise_migrations(database_url)
+
+
+def setup_dependencies(component: "PlatformServiceComponent", database_url: str):
+    """
+    Initialize dependencies for the Platform Service.
+
+    This function is idempotent and safe to call multiple times.
+    It sets up:
+    1. Component instance reference
+    2. Database connection
+    3. Middleware (CORS, OAuth2)
+    4. Routers (community and enterprise)
+
+    Args:
+        component: PlatformServiceComponent instance.
+        database_url: Database connection string.
+    """
+    global _dependencies_initialized
+
+    if _dependencies_initialized:
+        log.debug("Platform service dependencies already initialized, skipping")
+        return
+
+    log.info("Initializing Platform Service dependencies...")
+
+    # Store component reference for dependency injection
+    from . import dependencies
+
+    dependencies.set_component_instance(component)
+
+    # ALSO set gateway dependencies to allow webui_backend routers to work
+    # webui_backend routers use ValidatedUserConfig which expects sac_component_instance
+    try:
+        from solace_agent_mesh.gateway.http_sse import dependencies as gateway_deps
+        gateway_deps.sac_component_instance = component
+        log.info("Gateway dependencies configured to use platform component")
+    except ImportError:
+        log.debug("Gateway module not available - skipping gateway dependency setup")
+
+    # Initialize database and run migrations
+    if database_url:
+        _setup_database(database_url)
+        log.info("Platform database initialized with migrations")
+    else:
+        log.warning("No database URL provided - platform service will not function")
+
+    # Setup middleware
+    _setup_middleware(component)
+
+    # Setup routers
+    _setup_routers()
+
+    _dependencies_initialized = True
+    log.info("Platform Service dependencies initialized successfully")
+
+
+def _setup_middleware(component: "PlatformServiceComponent"):
+    """
+    Add middleware to the FastAPI application.
+
+    1. CORS middleware - allows cross-origin requests
+    2. OAuth2 middleware - authentication (uses enterprise implementation if available)
+
+    Args:
+        component: PlatformServiceComponent instance for configuration access.
+    """
+    # CORS middleware
+    allowed_origins = component.get_cors_origins()
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=allowed_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    log.info(f"CORS middleware added with origins: {allowed_origins}")
+
+    # OAuth2 middleware - try enterprise implementation first, fall back to stub
+    # try:
+    #     from solace_agent_mesh_enterprise.platform_service.middleware import create_oauth2_middleware
+    #
+    #     oauth2_middleware_class = create_oauth2_middleware(component)
+    #     app.add_middleware(oauth2_middleware_class)
+    #     log.info("Enterprise OAuth2 middleware added (real token validation)")
+    # except ImportError:
+    #     # Fall back to stub middleware if enterprise package not available
+    #     from .middleware import oauth2_stub_middleware
+    #
+    #     app.middleware("http")(oauth2_stub_middleware)
+    #     log.info("OAuth2 stub middleware added (development mode - no enterprise package)")
+
+
+def _setup_routers():
+    """
+    Mount community and enterprise routers to the FastAPI application.
+
+    Community routers: Loaded from .routers (empty in Phase 1)
+    Enterprise routers: Dynamically loaded from enterprise package if available
+    """
+    # Load community platform routers (empty in Phase 1)
+    from .routers import get_community_platform_routers
+
+    community_routers = get_community_platform_routers()
+    for router_config in community_routers:
+        app.include_router(
+            router_config["router"],
+            prefix=router_config["prefix"],
+            tags=router_config["tags"],
+        )
+    log.info(f"Mounted {len(community_routers)} community platform routers")
+
+    # Try to load enterprise platform routers
+    try:
+        from solace_agent_mesh_enterprise.webui_backend.routers import get_enterprise_routers
+
+        enterprise_routers = get_enterprise_routers()
+        for router_config in enterprise_routers:
+            app.include_router(
+                router_config["router"],
+                prefix=router_config["prefix"],
+                tags=router_config["tags"],
+            )
+        log.info(f"Mounted {len(enterprise_routers)} enterprise platform routers")
+
+    except ImportError:
+        log.info(
+            "No enterprise package detected - running in community mode (no platform endpoints available)"
+        )
+    except Exception as e:
+        log.warning(f"Failed to load enterprise platform routers: {e}")
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    """
+    Platform Service health check endpoint.
+
+    Returns:
+        Dictionary with status and service name.
+    """
+    log.debug("Health check endpoint '/health' called")
+    return {"status": "healthy", "service": "Platform Service"}