solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/routers/users.py

@@ -9,7 +9,7 @@ from typing import Any
 from fastapi import APIRouter, Depends, Query
 
 from ..dependencies import get_config_resolver, get_user_config
-from ..shared.auth_utils import get_current_user
+from solace_agent_mesh.shared.api.auth_utils import get_current_user
 from ....common.middleware.config_resolver import ConfigResolver
 
 log = logging.getLogger(__name__)

solace_agent_mesh/gateway/http_sse/routers/version.py

@@ -0,0 +1,343 @@
+"""
+API Router for providing version information about installed SAM products.
+"""
+
+import json
+import logging
+from importlib.metadata import version, PackageNotFoundError
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException, status
+
+from .dto.responses.version_responses import ProductInfo, VersionResponse
+
+log = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Constants
+NOT_INSTALLED = "not-installed"
+UNKNOWN_VERSION = "unknown"
+UI_VERSION_RELATIVE_PATH = Path("client") / "webui" / "frontend" / "static" / "ui-version.json"
+
+
+@router.get("/version", response_model=VersionResponse)
+async def get_version():
+    """
+    Returns version information for all installed SAM products and dependencies.
+
+    Detects and returns information only for products that are actually installed.
+    """
+    log_prefix = "[GET /api/v1/version] "
+    log.debug("%sRequest received.", log_prefix)
+
+    try:
+        products = []
+
+        # Add base solace-agent-mesh product
+        base_product = _get_base_product_info(log_prefix)
+        if base_product:
+            products.append(base_product)
+
+        # Add UI product
+        ui_product = _get_ui_product_info(log_prefix)
+        if ui_product:
+            products.append(ui_product)
+
+        # Add enterprise product if installed
+        enterprise_product = _get_enterprise_product_info(log_prefix)
+        if enterprise_product:
+            products.append(enterprise_product)
+
+        # Add solace-chat product if installed
+        chat_product = _get_solace_chat_product_info(log_prefix)
+        if chat_product:
+            products.append(chat_product)
+
+        log.debug(
+            "%sReturning version information for %d products",
+            log_prefix,
+            len(products),
+        )
+        return VersionResponse(products=products)
+
+    except Exception as e:
+        log.exception("%sError retrieving version information: %s", log_prefix, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to retrieve version information",
+        ) from e
+
+
+def _get_base_product_info(log_prefix: str) -> ProductInfo:
+    """
+    Get version information for the base solace-agent-mesh product.
+
+    Args:
+        log_prefix: Logging prefix for consistent log formatting
+
+    Returns:
+        ProductInfo with product information including key dependencies
+    """
+    base_version = _get_package_version("solace-agent-mesh", log_prefix)
+
+    # Collect dependencies and filter out those not installed
+    dependencies = {
+        "a2a-sdk": _get_package_version("a2a-sdk", log_prefix),
+        "google-adk": _get_package_version("google-adk", log_prefix),
+    }
+    # Filter out packages that are not installed
+    dependencies = {k: v for k, v in dependencies.items() if v != NOT_INSTALLED}
+
+    return ProductInfo(
+        id="solace-agent-mesh",
+        name="Solace Agent Mesh",
+        description="Open-source framework for event-driven, multi-agent AI systems",
+        version=base_version,
+        dependencies=dependencies if dependencies else None,
+    )
+
+
+def _get_ui_product_info(log_prefix: str) -> ProductInfo | None:
+    """
+    Get version information for the UI product.
+
+    Checks multiple locations for ui-version.json (enterprise, installed, dev)
+    and returns the first one found.
+
+    Args:
+        log_prefix: Logging prefix for consistent log formatting
+
+    Returns:
+        ProductInfo with UI product information, or None if not found
+    """
+    # Define all possible UI version file paths to check
+    ui_version_paths = [
+        _get_enterprise_ui_version_path(log_prefix),
+        _get_installed_ui_version_path(),
+        _get_dev_ui_version_path(),
+    ]
+
+    # Try each path in order until we find one that exists
+    for path in ui_version_paths:
+        if path is None:
+            continue
+
+        ui_metadata = _read_ui_version_file(path, log_prefix)
+        if ui_metadata:
+            try:
+                return ProductInfo(**ui_metadata)
+            except Exception as e:
+                log.warning(
+                    "%sInvalid ui-version.json format at %s: %s",
+                    log_prefix,
+                    path,
+                    e
+                )
+                # Continue to next path
+
+    # No UI version file found, return default info
+    log.debug("%sui-version.json not found in expected locations", log_prefix)
+    return _get_default_ui_product_info()
+
+
+def _get_enterprise_ui_version_path(log_prefix: str) -> Path | None:
+    """
+    Get the path to the enterprise UI version file if enterprise is installed.
+
+    Args:
+        log_prefix: Logging prefix for consistent log formatting
+
+    Returns:
+        Path to enterprise UI version file, or None if enterprise is not installed
+    """
+    enterprise_version = _get_package_version("solace-agent-mesh-enterprise", log_prefix)
+    if enterprise_version == NOT_INSTALLED:
+        return None
+
+    try:
+        import solace_agent_mesh_enterprise
+        enterprise_package_path = Path(solace_agent_mesh_enterprise.__file__).parent
+        ui_version_path = enterprise_package_path / UI_VERSION_RELATIVE_PATH
+        return ui_version_path
+    except ImportError as e:
+        log.debug("%sEnterprise package import failed: %s", log_prefix, e)
+        return None
+    except AttributeError as e:
+        log.warning("%sEnterprise package missing __file__ attribute: %s", log_prefix, e)
+        return None
+    except Exception as e:
+        log.warning("%sCould not locate enterprise UI version path: %s", log_prefix, e)
+        return None
+
+
+def _get_installed_ui_version_path() -> Path:
+    """
+    Get the path to the UI version file in the installed package location.
+
+    Returns:
+        Path to installed UI version file
+    """
+    # Path: routers -> http_sse -> gateway -> solace_agent_mesh (4 levels up)
+    current_file = Path(__file__)
+    base_package_path = current_file.parent.parent.parent.parent
+    ui_version_path = base_package_path / UI_VERSION_RELATIVE_PATH
+    return ui_version_path
+
+
+def _get_dev_ui_version_path() -> Path:
+    """
+    Get the path to the UI version file in the development location.
+
+    Returns:
+        Path to dev UI version file
+    """
+    # Path: src/solace_agent_mesh/... -> root/client/webui/frontend/static (6 levels up)
+    current_file = Path(__file__)
+    repo_root = current_file.parent.parent.parent.parent.parent.parent
+    ui_version_path = repo_root / UI_VERSION_RELATIVE_PATH
+    return ui_version_path
+
+
+def _read_ui_version_file(path: Path, log_prefix: str) -> dict | None:
+    """
+    Read and parse a UI version JSON file.
+
+    Args:
+        path: Path to the ui-version.json file
+        log_prefix: Logging prefix for consistent log formatting
+
+    Returns:
+        Parsed JSON metadata dict, or None if file doesn't exist or can't be read
+    """
+    if not path.exists():
+        return None
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            ui_metadata = json.load(f)
+            log.debug(
+                "%sUI version from %s: %s",
+                log_prefix,
+                path,
+                ui_metadata.get("version"),
+            )
+            return ui_metadata
+    except FileNotFoundError:
+        # File disappeared between exists() check and open() - rare race condition
+        log.debug("%sUI version file not found at %s", log_prefix, path)
+        return None
+    except PermissionError as e:
+        log.warning("%sPermission denied reading %s: %s", log_prefix, path, e)
+        return None
+    except json.JSONDecodeError as e:
+        log.error("%sInvalid JSON in %s: %s", log_prefix, path, e)
+        return None
+    except Exception as e:
+        log.warning("%sCould not read %s: %s", log_prefix, path, e)
+        return None
+
+
+def _get_default_ui_product_info() -> ProductInfo:
+    """
+    Get default UI product information when version file is not found.
+
+    Returns:
+        ProductInfo with default values
+    """
+    return ProductInfo(
+        id="@SolaceLabs/solace-agent-mesh-ui",
+        name="Solace Agent Mesh UI",
+        description="React UI components for Solace Agent Mesh",
+        version=UNKNOWN_VERSION,
+    )
+
+
+def _get_enterprise_product_info(log_prefix: str) -> ProductInfo | None:
+    """
+    Get version information for the enterprise product if installed.
+
+    Args:
+        log_prefix: Logging prefix for consistent log formatting
+
+    Returns:
+        ProductInfo with enterprise product information, or None if not installed
+    """
+    # Check if enterprise package is installed
+    enterprise_version = _get_package_version("solace-agent-mesh-enterprise", log_prefix)
+    if enterprise_version == NOT_INSTALLED:
+        log.debug("%sEnterprise package not installed", log_prefix)
+        return None
+
+    product_info = ProductInfo(
+        id="solace-agent-mesh-enterprise",
+        name="Solace Agent Mesh Enterprise",
+        description="Enterprise extensions with authorization and enterprise features",
+        version=enterprise_version,
+    )
+
+    log.debug("%sEnterprise package detected: %s", log_prefix, enterprise_version)
+    return product_info
+
+
+def _get_solace_chat_product_info(log_prefix: str) -> ProductInfo | None:
+    """
+    Get version information for the solace-chat product if installed.
+
+    Args:
+        log_prefix: Logging prefix for consistent log formatting
+
+    Returns:
+        ProductInfo with solace-chat product information, or None if not installed
+    """
+    # Check if solace-chat package is installed
+    chat_version = _get_package_version("solace-chat", log_prefix)
+    if chat_version == NOT_INSTALLED:
+        log.debug("%ssolace-chat package not installed", log_prefix)
+        return None
+
+    # solace-chat is installed, gather its information
+    # Collect dependencies and filter out those not installed
+    dependencies = {
+        "sam-bamboohr": _get_package_version("sam-bamboohr", log_prefix),
+        "sam-confluence": _get_package_version("sam-confluence", log_prefix),
+        "sam-jira": _get_package_version("sam-jira", log_prefix),
+        "sam-litellm": _get_package_version("sam-litellm", log_prefix),
+        "sam-rest-gateway": _get_package_version("sam-rest-gateway", log_prefix),
+        "sam-rt-sf": _get_package_version("sam-rt-sf", log_prefix),
+        "sam-s3-hosting": _get_package_version("sam-s3-hosting", log_prefix),
+        "sam-slack": _get_package_version("sam-slack", log_prefix),
+        "sam-sql-database": _get_package_version("sam-sql-database", log_prefix),
+        "sam-teams-gateway": _get_package_version("sam-teams-gateway", log_prefix),
+    }
+    # Filter out packages that are not installed
+    dependencies = {k: v for k, v in dependencies.items() if v != NOT_INSTALLED}
+
+    product_info = ProductInfo(
+        id="solace-chat",
+        name="Solace Chat",
+        description="Solace Chat Agent for agent-to-agent communication",
+        version=chat_version,
+        dependencies=dependencies if dependencies else None,
+    )
+
+    log.debug("%ssolace-chat package detected: %s", log_prefix, chat_version)
+    return product_info
+
+
+def _get_package_version(package_name: str, log_prefix: str) -> str:
+    """
+    Get the version of an installed package.
+
+    Args:
+        package_name: Name of the package to query
+        log_prefix: Logging prefix for consistent log formatting
+
+    Returns:
+        Version string, or "not-installed" if package is not found
+    """
+    try:
+        return version(package_name)
+    except PackageNotFoundError:
+        log.debug("%sPackage '%s' not found in installed packages", log_prefix, package_name)
+        return NOT_INSTALLED

solace_agent_mesh/gateway/http_sse/routers/visualization.py

@@ -1,6 +1,7 @@
 """
 API Router for managing A2A message visualization streams.
 """
+from __future__ import annotations
 
 import logging
 import asyncio
@@ -14,6 +15,7 @@ from fastapi import (
     status,
 )
 from pydantic import BaseModel, Field
+import json
 from typing import List, Optional, Dict, Any, Set
 
 
@@ -31,6 +33,7 @@ if TYPE_CHECKING:
     from ....gateway.http_sse.component import WebUIBackendComponent
 
 log = logging.getLogger(__name__)
+trace_logger = logging.getLogger("sam_trace")
 
 router = APIRouter()
 
@@ -45,7 +48,7 @@ class SubscriptionTarget(BaseModel):
             "my_a2a_messages",
             "current_namespace_a2a_messages",
             "namespace_a2a_messages",
-            "agent_a2a_messages",
+            "agent_a2a_messages"
         ],
     )
     identifier: Optional[str] = Field(
@@ -231,11 +234,77 @@ def _resolve_user_identity_for_authorization(
                 "%s No user_identity provided but authorization is enabled. This should not happen.",
                 log_id_prefix,
             )
-            raise ValueError("No user identity available when authorization is required")
+            raise ValueError(
+                "No user identity available when authorization is required"
+            )
 
     return user_identity
 
 
+def _include_for_visualization(event_payload: Dict[str, Any]) -> bool:
+    """
+    Check if an event should be included for visualization based on metadata.
+
+    Args:
+        event_payload: The event payload containing event data
+
+    Returns:
+        False if the event should be excluded from visualization (when visualization is False),
+        True otherwise (include by default)
+    """
+    try:
+        # Get the data field from the event payload
+        data_str = event_payload.get("data")
+        if not data_str:
+            return True  # Include by default if no data
+
+        # Parse the JSON data
+        try:
+            data = json.loads(data_str)
+        except (json.JSONDecodeError, TypeError):
+            return True
+
+        # Look for the full_payload in the data
+        full_payload = data.get("full_payload")
+        if not full_payload:
+            return True
+
+        # Check if full_payload has params
+        params = full_payload.get("params")
+        if not params:
+            return True
+
+        # Check if params has message
+        message = params.get("message")
+        if not message:
+            return True
+
+        # Check if message has metadata
+        metadata = message.get("metadata")
+        if not metadata:
+            return True
+
+        # Check the visualization setting in metadata
+        visualization_setting = metadata.get("visualization")
+        if visualization_setting is not None and (
+            (
+                isinstance(visualization_setting, str)
+                and visualization_setting.lower() == "false"
+            )
+            or (
+                isinstance(visualization_setting, bool)
+                and visualization_setting is False
+            )
+        ):
+            return False
+
+        return True
+
+    except Exception as e:
+        log.warning("Error checking visualization filter for event: %s", e)
+        return True
+
+
 @router.post(
     "/subscribe",
     response_model=VisualizationSubscribeResponse,
@@ -321,7 +390,7 @@ async def subscribe_to_visualization_stream(
     resolved_user_identity = _resolve_user_identity_for_authorization(
         component, user_id
     )
-    log.info(
+    log.debug(
         "%s Resolved user identity for authorization: '%s' (from raw user_id: '%s')",
         log_id_prefix,
         resolved_user_identity,
@@ -339,7 +408,7 @@ async def subscribe_to_visualization_stream(
         user_config = await config_resolver.resolve_user_config(
             resolved_user_identity, gateway_context, {}
         )
-        log.info(
+        log.debug(
             "%s Resolved user_config for resolved_user_identity '%s': %s",
             log_id_prefix,
             resolved_user_identity,
@@ -457,7 +526,7 @@ async def subscribe_to_visualization_stream(
                 )
 
                 firehose_topic = f"{component.namespace.strip('/')}/a2a/>"
-                log.info(
+                log.debug(
                     "%s Adding firehose subscription '%s' for my_a2a_messages stream.",
                     log_id_prefix,
                     firehose_topic,
@@ -780,13 +849,27 @@ async def get_visualization_stream_events(
                             stream_id,
                         )
                         break
-                    yield event_payload
+                    if _include_for_visualization(event_payload):
+                        if trace_logger.isEnabledFor(logging.DEBUG):
+                            trace_logger.debug(
+                                "%s Yielding event for stream %s: %s",
+                                log_id_prefix,
+                                stream_id,
+                                event_payload,
+                            )
+                        else:
+                            log.debug(
+                                "%s Yielding event for stream %s",
+                                log_id_prefix,
+                                stream_id,
+                            )
+                        yield event_payload
                     sse_queue.task_done()
                 except asyncio.TimeoutError:
                     yield {"comment": "keep-alive"}
                     continue
                 except asyncio.CancelledError:
-                    log.info(
+                    log.debug(
                         "%s SSE event generator for stream %s cancelled.",
                         log_id_prefix,
                         stream_id,
@@ -800,7 +883,7 @@ async def get_visualization_stream_events(
                 e,
             )
         finally:
-            log.info(
+            log.debug(
                 "%s SSE event generator for stream %s finished.",
                 log_id_prefix,
                 stream_id,
@@ -1135,4 +1218,4 @@ async def unsubscribe_from_visualization_stream(
     return Response(status_code=status.HTTP_204_NO_CONTENT)
 
 
-log.info("Router for A2A Message Visualization initialized.")
+log.info("Initialized Router for A2A Message Visualization.")