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

solace_agent_mesh/gateway/http_sse/utils/artifact_copy_utils.py

@@ -0,0 +1,370 @@
+"""
+Utility functions for copying project artifacts to sessions.
+"""
+
+import logging
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
+
+from sqlalchemy.orm import Session as DbSession
+
+from ....agent.utils.artifact_helpers import (
+    get_artifact_info_list,
+    load_artifact_content_or_metadata,
+    save_artifact_with_metadata,
+)
+
+if TYPE_CHECKING:
+    from ....gateway.http_sse.component import WebUIBackendComponent
+    from ....gateway.http_sse.services.project_service import ProjectService
+
+try:
+    from google.adk.artifacts import BaseArtifactService
+except ImportError:
+    class BaseArtifactService:
+        pass
+
+
+log = logging.getLogger(__name__)
+
+
+async def has_pending_project_context(
+    user_id: str,
+    session_id: str,
+    artifact_service: BaseArtifactService,
+    app_name: str,
+    db: DbSession,
+) -> bool:
+    """
+    Check if session has any artifacts with pending project context.
+
+    This is used to determine if we should inject full project context
+    on the next user message after a session has been moved to a project.
+
+    Args:
+        user_id: User ID
+        session_id: Session ID
+        artifact_service: Artifact service instance
+        app_name: Application name for artifact storage
+        db: Database session
+
+    Returns:
+        True if any artifacts have project_context_pending=True metadata
+    """
+    try:
+        session_artifacts = await get_artifact_info_list(
+            artifact_service=artifact_service,
+            app_name=app_name,
+            user_id=user_id,
+            session_id=session_id,
+        )
+
+        # Check each artifact's metadata to see if it has pending project context
+        for artifact_info in session_artifacts:
+            loaded_metadata = await load_artifact_content_or_metadata(
+                artifact_service=artifact_service,
+                app_name=app_name,
+                user_id=user_id,
+                session_id=session_id,
+                filename=artifact_info.filename,
+                load_metadata_only=True,
+                version="latest",
+            )
+
+            if loaded_metadata.get("status") == "success":
+                metadata = loaded_metadata.get("metadata", {})
+                if metadata.get("project_context_pending"):
+                    return True
+
+        return False
+    except Exception as e:
+        log.warning("Failed to check for pending project context: %s", e)
+        return False
+
+
+async def clear_pending_project_context(
+    user_id: str,
+    session_id: str,
+    artifact_service: BaseArtifactService,
+    app_name: str,
+    db: DbSession,
+    log_prefix: str = "",
+) -> None:
+    """
+    Clear the project_context_pending flag from all artifacts in a session.
+
+    This should be called after project context has been injected to the agent.
+
+    Args:
+        user_id: User ID
+        session_id: Session ID
+        artifact_service: Artifact service instance
+        app_name: Application name for artifact storage
+        db: Database session
+        log_prefix: Optional prefix for log messages
+    """
+    try:
+        session_artifacts = await get_artifact_info_list(
+            artifact_service=artifact_service,
+            app_name=app_name,
+            user_id=user_id,
+            session_id=session_id,
+        )
+
+        for artifact_info in session_artifacts:
+            loaded_metadata = await load_artifact_content_or_metadata(
+                artifact_service=artifact_service,
+                app_name=app_name,
+                user_id=user_id,
+                session_id=session_id,
+                filename=artifact_info.filename,
+                load_metadata_only=True,
+                version="latest",
+            )
+
+            if loaded_metadata.get("status") == "success":
+                metadata = loaded_metadata.get("metadata", {})
+
+                # Only update if the artifact has the pending flag
+                if metadata.get("project_context_pending"):
+                    log.debug(
+                        "%sClearing project_context_pending flag for artifact %s",
+                        log_prefix,
+                        artifact_info.filename,
+                    )
+
+                    # Remove the pending flag
+                    metadata.pop("project_context_pending", None)
+
+                    loaded_artifact = await load_artifact_content_or_metadata(
+                        artifact_service=artifact_service,
+                        app_name=app_name,
+                        user_id=user_id,
+                        session_id=session_id,
+                        filename=artifact_info.filename,
+                        return_raw_bytes=True,
+                        version="latest",
+                    )
+
+                    if loaded_artifact.get("status") == "success":
+                        await save_artifact_with_metadata(
+                            artifact_service=artifact_service,
+                            app_name=app_name,
+                            user_id=user_id,
+                            session_id=session_id,
+                            filename=artifact_info.filename,
+                            content_bytes=loaded_artifact.get("raw_bytes"),
+                            mime_type=loaded_artifact.get("mime_type"),
+                            metadata_dict=metadata,
+                            timestamp=datetime.now(timezone.utc),
+                        )
+    except Exception as e:
+        log.warning("%sFailed to clear pending project context flags: %s", log_prefix, e)
+
+
+async def copy_project_artifacts_to_session(
+    project_id: str,
+    user_id: str,
+    session_id: str,
+    project_service: "ProjectService",
+    component: "WebUIBackendComponent",
+    db: "DbSession",
+    log_prefix: str = "",
+) -> tuple[int, list[str]]:
+    """
+    Copy all artifacts from a project to a session.
+
+    This function handles:
+    - Loading artifacts from the project storage
+    - Checking which artifacts already exist in the session
+    - Copying new artifacts to the session
+    - Setting the 'source' metadata field to 'project'
+
+    Args:
+        project_id: ID of the project containing artifacts
+        user_id: ID of the user (for session artifact storage)
+        session_id: ID of the session to copy artifacts to
+        project_service: ProjectService instance for accessing projects
+        component: WebUIBackendComponent for accessing artifact service
+        db: Database session to use for queries
+        log_prefix: Optional prefix for log messages
+
+    Returns:
+        Tuple of (artifacts_copied_count, list_of_new_artifact_names)
+
+    Raises:
+        Exception: If project or artifact service is not available
+    """
+    if not project_id:
+        log.debug("%sNo project_id provided, skipping artifact copy", log_prefix)
+        return 0, []
+
+    if db is None:
+        log.warning("%sArtifact copy skipped: database session not provided", log_prefix)
+        return 0, []
+
+    try:
+        project = project_service.get_project(db, project_id, user_id)
+        if not project:
+            log.warning("%sProject %s not found for user %s", log_prefix, project_id, user_id)
+            return 0, []
+
+        artifact_service = component.get_shared_artifact_service()
+        if not artifact_service:
+            log.warning("%sArtifact service not available", log_prefix)
+            return 0, []
+
+        source_user_id = project.user_id
+        project_artifacts_session_id = f"project-{project.id}"
+
+        log.info(
+            "%sChecking for artifacts in project %s (storage session: %s)",
+            log_prefix,
+            project.id,
+            project_artifacts_session_id,
+        )
+
+        # Get list of artifacts in the project
+        project_artifacts = await get_artifact_info_list(
+            artifact_service=artifact_service,
+            app_name=project_service.app_name,
+            user_id=source_user_id,
+            session_id=project_artifacts_session_id,
+        )
+
+        if not project_artifacts:
+            log.info("%sNo artifacts found in project %s", log_prefix, project.id)
+            return 0, []
+
+        log.info(
+            "%sFound %d artifacts in project %s to process",
+            log_prefix,
+            len(project_artifacts),
+            project.id,
+        )
+
+        try:
+            session_artifacts = await get_artifact_info_list(
+                artifact_service=artifact_service,
+                app_name=project_service.app_name,
+                user_id=user_id,
+                session_id=session_id,
+            )
+            session_artifact_names = {art.filename for art in session_artifacts}
+            log.debug(
+                "%sSession %s currently has %d artifacts",
+                log_prefix,
+                session_id,
+                len(session_artifact_names),
+            )
+        except Exception as e:
+            log.warning(
+                "%sFailed to get session artifacts, will copy all project artifacts: %s",
+                log_prefix,
+                e,
+            )
+            session_artifact_names = set()
+
+        artifacts_copied = 0
+        new_artifact_names = []
+
+        for artifact_info in project_artifacts:
+            # Skip if artifact already exists in session
+            if artifact_info.filename in session_artifact_names:
+                log.debug(
+                    "%sSkipping artifact %s - already exists in session",
+                    log_prefix,
+                    artifact_info.filename,
+                )
+                continue
+
+            new_artifact_names.append(artifact_info.filename)
+
+            log.info(
+                "%sCopying artifact %s to session %s",
+                log_prefix,
+                artifact_info.filename,
+                session_id,
+            )
+
+            try:
+                # Load artifact content from project storage
+                loaded_artifact = await load_artifact_content_or_metadata(
+                    artifact_service=artifact_service,
+                    app_name=project_service.app_name,
+                    user_id=source_user_id,
+                    session_id=project_artifacts_session_id,
+                    filename=artifact_info.filename,
+                    return_raw_bytes=True,
+                    version="latest",
+                )
+
+                # Load the full metadata separately
+                loaded_metadata = await load_artifact_content_or_metadata(
+                    artifact_service=artifact_service,
+                    app_name=project_service.app_name,
+                    user_id=source_user_id,
+                    session_id=project_artifacts_session_id,
+                    filename=artifact_info.filename,
+                    load_metadata_only=True,
+                    version="latest",
+                )
+
+                # Save a copy to the current chat session
+                if loaded_artifact.get("status") == "success":
+                    full_metadata = (
+                        loaded_metadata.get("metadata", {})
+                        if loaded_metadata.get("status") == "success"
+                        else {}
+                    )
+
+                    # This flag will be checked on the next user message to inject full context
+                    full_metadata["project_context_pending"] = True
+
+                    await save_artifact_with_metadata(
+                        artifact_service=artifact_service,
+                        app_name=project_service.app_name,
+                        user_id=user_id,
+                        session_id=session_id,
+                        filename=artifact_info.filename,
+                        content_bytes=loaded_artifact.get("raw_bytes"),
+                        mime_type=loaded_artifact.get("mime_type"),
+                        metadata_dict=full_metadata,
+                        timestamp=datetime.now(timezone.utc),
+                    )
+                    artifacts_copied += 1
+                    log.info(
+                        "%sSuccessfully copied artifact %s to session",
+                        log_prefix,
+                        artifact_info.filename,
+                    )
+                else:
+                    log.warning(
+                        "%sFailed to load artifact %s: %s",
+                        log_prefix,
+                        artifact_info.filename,
+                        loaded_artifact.get("status"),
+                    )
+            except Exception as e:
+                log.error(
+                    "%sError copying artifact %s to session: %s",
+                    log_prefix,
+                    artifact_info.filename,
+                    e,
+                )
+                
+        if artifacts_copied > 0:
+            log.info(
+                "%sCopied %d new artifacts to session %s",
+                log_prefix,
+                artifacts_copied,
+                session_id,
+            )
+        else:
+            log.debug("%sNo new artifacts to copy to session %s", log_prefix, session_id)
+
+        return artifacts_copied, new_artifact_names
+
+    except Exception as e:
+        log.warning("%sFailed to copy project artifacts to session: %s", log_prefix, e)
+        return 0, []

solace_agent_mesh/gateway/http_sse/utils/stim_utils.py

@@ -2,7 +2,7 @@
 Utility functions for creating .stim file structures.
 """
 
-from typing import List
+from typing import Dict, List
 
 from ..repository.entities import Task, TaskEvent
 
@@ -30,3 +30,43 @@ def create_stim_from_task_data(task: Task, events: List[TaskEvent]) -> dict:
         },
         "invocation_flow": [event.model_dump() for event in events],
     }
+
+
+def create_stim_from_task_hierarchy(
+    tasks: Dict[str, Task], all_events: Dict[str, List[TaskEvent]], root_task_id: str
+) -> dict:
+    """
+    Formats a task hierarchy (parent + children) and all their events into the .stim file structure.
+
+    Args:
+        tasks: Dictionary of task_id -> Task entity for all tasks in hierarchy.
+        all_events: Dictionary of task_id -> List[TaskEvent] for all tasks.
+        root_task_id: The root task ID (used for invocation_details).
+
+    Returns:
+        A dictionary representing the .stim file content with all task events.
+    """
+    root_task = tasks[root_task_id]
+
+    # Collect all events from all tasks and sort by created_time
+    combined_events = []
+    for task_id, events in all_events.items():
+        combined_events.extend(events)
+
+    # Sort all events chronologically
+    combined_events.sort(key=lambda e: e.created_time)
+
+    return {
+        "invocation_details": {
+            "log_file_version": "2.0",  # New version for gateway-generated logs
+            "task_id": root_task.id,
+            "user_id": root_task.user_id,
+            "start_time": root_task.start_time,
+            "end_time": root_task.end_time,
+            "status": root_task.status,
+            "initial_request_text": root_task.initial_request_text,
+            "includes_child_tasks": len(tasks) > 1,
+            "total_tasks": len(tasks),
+        },
+        "invocation_flow": [event.model_dump() for event in combined_events],
+    }

solace_agent_mesh/services/platform/__init__.py

@@ -0,0 +1,29 @@
+"""
+Platform Service for Solace Agent Mesh.
+
+ARCHITECTURE: Service vs Gateway
+--------------------------------
+SERVICES provide internal platform functionality (this component).
+GATEWAYS handle external communication channels (http_sse, slack, webhook, etc.).
+
+Platform Service Responsibilities:
+- REST API for platform configuration management
+- Agent Builder (CRUD operations on agents)
+- Connector management (CRUD operations on connectors)
+- Toolset discovery and management
+- Deployment orchestration (deploy/update/undeploy agents)
+- AI Assistant (AI-powered configuration help)
+- Deployer heartbeat monitoring (track deployer availability)
+- Background deployment status checking (verify agent deployments succeed)
+
+Message Communication (Direct Messaging - Not A2A Protocol):
+- PUBLISHES: Deployment commands (direct publishing) to deployer ({namespace}/deployer/agent/...)
+- RECEIVES: Deployer heartbeats ({namespace}/deployer/heartbeat)
+- RECEIVES: Agent cards for deployment monitoring ({namespace}/a2a/agent-cards)
+
+What Platform Service is NOT:
+- NOT a chat interface (no user sessions)
+- NOT for task submission to agents (no orchestration of user tasks)
+- NOT for artifact management (no chat artifacts or embeds)
+- NOT for end-user communication (admin/platform operations only)
+"""

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.
+"""