solace-agent-mesh 1.11.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

@@ -0,0 +1,72 @@
+"""
+Utility functions for creating .stim file structures.
+"""
+
+from typing import Dict, List
+
+from ..repository.entities import Task, TaskEvent
+
+
+def create_stim_from_task_data(task: Task, events: List[TaskEvent]) -> dict:
+    """
+    Formats a task and its events into the .stim file structure.
+
+    Args:
+        task: The task entity.
+        events: A list of task event entities.
+
+    Returns:
+        A dictionary representing the .stim file content.
+    """
+    return {
+        "invocation_details": {
+            "log_file_version": "2.0",  # New version for gateway-generated logs
+            "task_id": task.id,
+            "user_id": task.user_id,
+            "start_time": task.start_time,
+            "end_time": task.end_time,
+            "status": task.status,
+            "initial_request_text": task.initial_request_text,
+        },
+        "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/gateway/http_sse/utils/utils_llm.txt

@@ -0,0 +1,47 @@
+## Quick Summary
+The `utils` directory provides utility functions for the HTTP SSE Gateway, specifically for creating .stim file structures from task and event data.
+
+## Files Overview
+- `__init__.py` - Package initialization file for HTTP SSE Gateway utilities
+- `stim_utils.py` - Utility functions for formatting task data into .stim file structures
+
+## Developer API Reference
+
+### __init__.py
+**Purpose:** Package initialization for HTTP SSE Gateway utilities
+**Import:** `from solace_agent_mesh.gateway.http_sse.utils import *`
+
+This file serves as the package entry point and contains no public interfaces.
+
+### stim_utils.py
+**Purpose:** Provides utility functions for creating .stim file structures from task and event data
+**Import:** `from solace_agent_mesh.gateway.http_sse.utils.stim_utils import create_stim_from_task_data`
+
+**Functions:**
+- `create_stim_from_task_data(task: Task, events: List[TaskEvent]) -> dict` - Formats a task and its events into the .stim file structure with version 2.0 format for gateway-generated logs
+
+**Usage Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.utils.stim_utils import create_stim_from_task_data
+from solace_agent_mesh.gateway.http_sse.repository.entities import Task, TaskEvent
+
+# Create a .stim file structure from task and events
+task = Task(
+    id="task_123",
+    user_id="user_456", 
+    start_time="2024-01-01T10:00:00Z",
+    end_time="2024-01-01T10:05:00Z",
+    status="completed",
+    initial_request_text="Process this data"
+)
+
+events = [
+    TaskEvent(event_type="start", timestamp="2024-01-01T10:00:00Z"),
+    TaskEvent(event_type="complete", timestamp="2024-01-01T10:05:00Z")
+]
+
+stim_data = create_stim_from_task_data(task, events)
+# Returns a dictionary with 'invocation_details' and 'invocation_flow' keys
+```
+
+# content_hash: 7fdc4ad8bbcefb07ee40f84c438f988cda4fdfb812dab55c6a064d1b38b0c83f