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

solace_agent_mesh/services/platform/api/dependencies.py

@@ -7,7 +7,7 @@ Provides database sessions, component instance access, and user authentication.
 import logging
 from typing import TYPE_CHECKING, Generator
 
-from fastapi import HTTPException, Request, status
+from fastapi import HTTPException, status
 from sqlalchemy import create_engine, event, pool
 from sqlalchemy.engine.url import make_url
 from sqlalchemy.orm import Session, sessionmaker
@@ -124,24 +124,31 @@ def get_platform_db() -> Generator[Session, None, None]:
         db.close()
 
 
-def get_current_user(request: Request) -> dict:
+def get_heartbeat_tracker():
     """
-    FastAPI dependency to extract authenticated user from request state.
+    Get the heartbeat tracker from platform component.
 
-    The user is set by the OAuth2 middleware during request processing.
-
-    Args:
-        request: FastAPI Request object.
+    Used by deployer status endpoint to check if deployer is online.
 
     Returns:
-        Dictionary containing user information (user_id, email, name, etc.).
+        HeartbeatTracker instance if initialized, None otherwise.
+    """
+    if platform_component_instance is None:
+        log.warning("Platform component not initialized - heartbeat tracker unavailable")
+        return None
+    return platform_component_instance.get_heartbeat_tracker()
 
-    Raises:
-        HTTPException: 401 if user is not authenticated.
+
+def get_agent_registry():
     """
-    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
+    Get the agent registry from platform component.
+
+    Used for deployment status monitoring.
+
+    Returns:
+        AgentRegistry instance if initialized, None otherwise.
+    """
+    if platform_component_instance is None:
+        log.warning("Platform component not initialized - agent registry unavailable")
+        return None
+    return platform_component_instance.get_agent_registry()

solace_agent_mesh/services/platform/api/main.py

@@ -100,7 +100,7 @@ def _run_enterprise_migrations(database_url: str) -> None:
         database_url: Database connection string.
     """
     try:
-        from solace_agent_mesh_enterprise.webui_backend.migration_runner import run_migrations
+        from solace_agent_mesh_enterprise.platform_service.migration_runner import run_migrations
 
         log.info("Starting enterprise platform migrations...")
         run_migrations(database_url)
@@ -166,15 +166,6 @@ def setup_dependencies(component: "PlatformServiceComponent", database_url: str)
 
     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)
@@ -192,18 +183,102 @@ def setup_dependencies(component: "PlatformServiceComponent", database_url: str)
     log.info("Platform Service dependencies initialized successfully")
 
 
+async def _start_enterprise_platform_tasks(component: "PlatformServiceComponent") -> None:
+    """
+    Start enterprise platform background tasks if enterprise package is available.
+
+    This follows the exact same pattern as WebUI Gateway:
+    - Community calls enterprise function
+    - Enterprise owns all background task logic
+    - Graceful degradation if enterprise not available
+
+    Background tasks (enterprise-only):
+    - Heartbeat listener (deployer monitoring)
+    - Deployment status checker (agent deployment monitoring)
+    - Agent registry (tracks deployed agents)
+
+    Args:
+        component: PlatformServiceComponent instance
+    """
+    try:
+        from solace_agent_mesh_enterprise.init_enterprise import (
+            start_platform_background_tasks,
+        )
+
+        log.info("Starting enterprise platform background tasks...")
+        await start_platform_background_tasks(component)
+        log.info("Enterprise platform background tasks started successfully")
+
+    except ImportError:
+        log.info(
+            "Enterprise package not available - platform background tasks will not start. "
+            "Platform Service will run without deployment monitoring and deployer heartbeat tracking."
+        )
+    except RuntimeError as enterprise_err:
+        log.warning(
+            "Enterprise platform tasks disabled: %s - Platform Service will continue without deployment monitoring",
+            enterprise_err,
+        )
+    except Exception as enterprise_err:
+        log.error(
+            "Failed to start enterprise platform tasks: %s - Platform Service will continue",
+            enterprise_err,
+            exc_info=True,
+        )
+
+
 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)
+    2. OAuth2 middleware - authentication (real token validation)
 
     Args:
         component: PlatformServiceComponent instance for configuration access.
     """
-    # CORS middleware
-    allowed_origins = component.get_cors_origins()
+    # CORS middleware - automatically trust configured UI origins
+    configured_origins = component.get_cors_origins().copy()
+
+    # Automatically add frontend and platform service URLs as trusted origins
+    # These are admin-controlled values that should always be trusted
+    frontend_url = os.getenv("FRONTEND_SERVER_URL", "").strip()
+    platform_url = os.getenv("PLATFORM_SERVICE_URL", "").strip()
+
+    # Auto-construct frontend URL if not provided
+    if not frontend_url:
+        # Read WebUI Gateway configuration from environment variables
+        fastapi_host = os.getenv("FASTAPI_HOST", "127.0.0.1").strip()
+        fastapi_port = os.getenv("FASTAPI_PORT", "8000").strip()
+        ssl_keyfile = os.getenv("SSL_KEYFILE", "").strip()
+        ssl_certfile = os.getenv("SSL_CERTFILE", "").strip()
+
+        # Determine protocol and port based on SSL configuration
+        if ssl_keyfile and ssl_certfile:
+            protocol = "https"
+            port = os.getenv("FASTAPI_HTTPS_PORT", "8443").strip()
+        else:
+            protocol = "http"
+            port = fastapi_port
+
+        # Use 'localhost' if host is 127.0.0.1 for better compatibility
+        host = "localhost" if fastapi_host == "127.0.0.1" else fastapi_host
+        frontend_url = f"{protocol}://{host}:{port}"
+
+        log.info(
+            "FRONTEND_SERVER_URL not configured, auto-constructed from WebUI Gateway settings: %s",
+            frontend_url
+        )
+
+    auto_trusted_origins = []
+    if frontend_url:
+        auto_trusted_origins.append(frontend_url)
+    if platform_url:
+        auto_trusted_origins.append(platform_url)
+
+    # Combine and deduplicate
+    allowed_origins = list(set(auto_trusted_origins + configured_origins))
+
     app.add_middleware(
         CORSMiddleware,
         allow_origins=allowed_origins,
@@ -212,53 +287,61 @@ def _setup_middleware(component: "PlatformServiceComponent"):
         allow_headers=["*"],
     )
     log.info(f"CORS middleware added with origins: {allowed_origins}")
+    if auto_trusted_origins:
+        log.info(f"  Auto-added trusted origins: {auto_trusted_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)")
+    # OAuth2 authentication middleware
+    from solace_agent_mesh.shared.auth.middleware import create_oauth_middleware
+
+    oauth_middleware_class = create_oauth_middleware(component)
+    app.add_middleware(oauth_middleware_class, component=component)
+
+    use_auth = component.get_config("frontend_use_authorization", False)
+    if use_auth:
+        log.info("OAuth2 middleware added (real token validation enabled)")
+    else:
+        log.info("OAuth2 middleware added (development mode - frontend_use_authorization=false)")
 
 
 def _setup_routers():
     """
     Mount community and enterprise routers to the FastAPI application.
 
-    Community routers: Loaded from .routers (empty in Phase 1)
+    All platform service routers (both community and enterprise) are mounted
+    under the PLATFORM_SERVICE_PREFIX. This ensures a consistent API structure
+    where /api/v1/platform/* contains all platform management endpoints.
+
+    Community routers: Loaded from .routers
     Enterprise routers: Dynamically loaded from enterprise package if available
     """
-    # Load community platform routers (empty in Phase 1)
+    # Define the platform service API prefix
+    # This is the single source of truth for all platform service endpoints
+    PLATFORM_SERVICE_PREFIX = "/api/v1/platform"
+
+    # Load community platform routers
     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"],
+            prefix=PLATFORM_SERVICE_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
+        from solace_agent_mesh_enterprise.platform_service.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"],
+                prefix=PLATFORM_SERVICE_PREFIX,
                 tags=router_config["tags"],
             )
-        log.info(f"Mounted {len(enterprise_routers)} enterprise platform routers")
+        log.info(f"Mounted {len(enterprise_routers)} enterprise platform routers under {PLATFORM_SERVICE_PREFIX}")
 
     except ImportError:
         log.info(
@@ -267,14 +350,6 @@ def _setup_routers():
     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"}
+    from solace_agent_mesh.shared.exceptions.exception_handlers import register_exception_handlers
+    register_exception_handlers(app)
+    log.info("Registered shared exception handlers")

solace_agent_mesh/services/platform/api/routers/__init__.py

@@ -1,7 +1,7 @@
 """
 Community platform routers for Platform Service.
 
-Currently empty - no community endpoints yet.
+Provides foundational platform service endpoints available to all deployments.
 """
 
 
@@ -9,16 +9,25 @@ def get_community_platform_routers() -> list:
     """
     Return list of community platform routers.
 
+    Format:
     [
         {
             "router": router_instance,
-            "prefix": "/api/v1/platform",
             "tags": ["Platform"]
         },
         ...
     ]
 
+    Note: The prefix "/api/v1/platform" is applied by main.py when mounting these routers.
+
     Returns:
         Community platform routers list.
     """
-    return []
+    from .health_router import router as health_router
+
+    return [
+        {
+            "router": health_router,
+            "tags": ["Health"],
+        }
+    ]

solace_agent_mesh/services/platform/api/routers/health_router.py

@@ -0,0 +1,31 @@
+"""
+Platform Service health check router.
+
+Provides health status endpoint for monitoring and load balancer health checks.
+"""
+
+import logging
+from fastapi import APIRouter
+
+log = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+@router.get("/health", tags=["Health"])
+async def health_check():
+    """
+    Platform Service health check endpoint.
+
+    This endpoint is used by:
+    - Kubernetes liveness/readiness probes
+    - Load balancer health checks (ALB, NGINX)
+    - External monitoring systems
+
+    Returns:
+        dict: Health status with service name.
+            - status (str): "healthy" if service is operational
+            - service (str): Service identifier
+    """
+    log.debug("Health check endpoint '/api/v1/platform/health' called")
+    return {"status": "healthy", "service": "Platform Service"}

solace_agent_mesh/services/platform/app.py

@@ -9,6 +9,7 @@ from typing import Any, Dict, List
 from solace_ai_connector.flow.app import App
 
 from .component import PlatformServiceComponent
+from ...common.a2a import get_discovery_topic
 
 log = logging.getLogger(__name__)
 
@@ -53,6 +54,34 @@ class PlatformServiceApp(App):
             "default": 8001,
             "description": "Port for the embedded FastAPI server.",
         },
+        {
+            "name": "fastapi_https_port",
+            "required": False,
+            "type": "integer",
+            "default": 8444,
+            "description": "Port for the embedded FastAPI server when SSL is enabled.",
+        },
+        {
+            "name": "ssl_keyfile",
+            "required": False,
+            "type": "string",
+            "default": "",
+            "description": "The file path to the SSL private key.",
+        },
+        {
+            "name": "ssl_certfile",
+            "required": False,
+            "type": "string",
+            "default": "",
+            "description": "The file path to the SSL certificate.",
+        },
+        {
+            "name": "ssl_keyfile_password",
+            "required": False,
+            "type": "string",
+            "default": "",
+            "description": "The passphrase for the SSL private key.",
+        },
         {
             "name": "cors_allowed_origins",
             "required": False,
@@ -70,28 +99,93 @@ class PlatformServiceApp(App):
             "name": "external_auth_provider",
             "required": False,
             "type": "string",
-            "default": "azure",
-            "description": "OAuth2 provider name (e.g., 'azure', 'google', 'okta').",
+            "default": "",
+            "description": "The external authentication provider.",
         },
         {
-            "name": "use_authorization",
+            "name": "frontend_use_authorization",
             "required": False,
             "type": "boolean",
-            "default": True,
-            "description": "Enable OAuth2 token validation. Set to false for development mode.",
+            "default": False,
+            "description": "Enable OAuth2 token validation. When true, all API requests must include valid OAuth2 bearer tokens.",
+        },
+        {
+            "name": "max_message_size_bytes",
+            "required": False,
+            "type": "integer",
+            "default": 10000000,
+            "description": "Maximum message size in bytes for A2A messages (default: 10MB).",
+        },
+        {
+            "name": "deployment_timeout_minutes",
+            "required": False,
+            "type": "integer",
+            "default": 5,
+            "description": "Timeout for agent deployments (default: 5 minutes).",
+        },
+        {
+            "name": "heartbeat_timeout_seconds",
+            "required": False,
+            "type": "integer",
+            "default": 90,
+            "description": "Deployer heartbeat timeout in seconds (default: 90 seconds).",
+        },
+        {
+            "name": "deployment_check_interval_seconds",
+            "required": False,
+            "type": "integer",
+            "default": 60,
+            "description": "Interval for checking deployment status in seconds (default: 60 seconds).",
         },
     ]
 
     def __init__(self, app_info: Dict[str, Any], **kwargs):
         """
         Initialize the PlatformServiceApp.
-        Most setup is handled by the base App class.
+        Programmatically creates the component and configures broker before calling parent App.__init__().
         """
         log.debug(
             "%s Initializing PlatformServiceApp...",
             app_info.get("name", "PlatformServiceApp"),
         )
-        super().__init__(app_info, **kwargs)
+
+        modified_app_info = app_info.copy()
+        app_config = modified_app_info.get("app_config", {})
+
+        # Get namespace from config
+        namespace = app_config.get("namespace", "")
+        if not namespace:
+            raise ValueError("Namespace is required in app_config for PlatformServiceApp")
+
+        # Create subscriptions for agent discovery
+        subscriptions = [
+            {"topic": get_discovery_topic(namespace)},
+        ]
+
+        # Create component definition with subscriptions
+        # (SAC framework looks for subscriptions in component definition for simplified apps)
+        component_definition = {
+            "name": f"{app_info.get('name', 'platform_service')}_component",
+            "component_class": PlatformServiceComponent,
+            "component_config": {"app_config": app_config},
+            "subscriptions": subscriptions,
+        }
+
+        modified_app_info["components"] = [component_definition]
+
+        # Configure broker connection
+        broker_config = modified_app_info.setdefault("broker", {})
+        broker_config["input_enabled"] = True
+        broker_config["output_enabled"] = True
+
+        log.info(
+            "Configured broker for Platform Service with namespace: %s and %d subscription(s): %s",
+            namespace,
+            len(subscriptions),
+            subscriptions
+        )
+
+        super().__init__(modified_app_info, **kwargs)
         log.debug("%s PlatformServiceApp initialization complete.", self.name)
 
     def get_component(self) -> PlatformServiceComponent | None: