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

solace_agent_mesh/gateway/http_sse/routers/sessions.py

@@ -1,4 +1,5 @@
 import logging
+from typing import Optional
 from fastapi import APIRouter, Body, Depends, HTTPException, Query, status
 from sqlalchemy.orm import Session
 
@@ -10,6 +11,8 @@ from ..shared.response_utils import create_data_response
 from .dto.requests.session_requests import (
     GetSessionRequest,
     UpdateSessionRequest,
+    MoveSessionRequest,
+    SearchSessionsRequest,
 )
 from .dto.requests.task_requests import SaveTaskRequest
 from .dto.responses.session_responses import SessionResponse
@@ -24,6 +27,7 @@ SESSION_NOT_FOUND_MSG = "Session not found."
 
 @router.get("/sessions", response_model=PaginatedResponse[SessionResponse])
 async def get_all_sessions(
+    project_id: Optional[str] = Query(default=None, alias="project_id"),
     page_number: int = Query(default=1, ge=1, alias="pageNumber"),
     page_size: int = Query(default=20, ge=1, le=100, alias="pageSize"),
     db: Session = Depends(get_db),
@@ -31,10 +35,14 @@ async def get_all_sessions(
     session_service: SessionService = Depends(get_session_business_service),
 ):
     user_id = user.get("id")
+    log_msg = f"User '{user_id}' is listing sessions with pagination (page={page_number}, size={page_size})"
+    if project_id:
+        log_msg += f" filtered by project_id={project_id}"
+    log.info(log_msg)
 
     try:
         pagination = PaginationParams(page_number=page_number, page_size=page_size)
-        paginated_response = session_service.get_user_sessions(db, user_id, pagination)
+        paginated_response = session_service.get_user_sessions(db, user_id, pagination, project_id=project_id)
 
         session_responses = []
         for session_domain in paginated_response.data:
@@ -43,6 +51,8 @@ async def get_all_sessions(
                 user_id=session_domain.user_id,
                 name=session_domain.name,
                 agent_id=session_domain.agent_id,
+                project_id=session_domain.project_id,
+                project_name=session_domain.project_name,
                 created_time=session_domain.created_time,
                 updated_time=session_domain.updated_time,
             )
@@ -58,6 +68,63 @@ async def get_all_sessions(
         ) from e
 
 
+@router.get("/sessions/search", response_model=PaginatedResponse[SessionResponse])
+async def search_sessions(
+    query: str = Query(..., min_length=1, description="Search query"),
+    project_id: Optional[str] = Query(default=None, alias="projectId"),
+    page_number: int = Query(default=1, ge=1, alias="pageNumber"),
+    page_size: int = Query(default=20, ge=1, le=100, alias="pageSize"),
+    db: Session = Depends(get_db),
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_business_service),
+):
+    """
+    Search sessions by name or content.
+    """
+    user_id = user.get("id")
+    log.info(
+        "User %s searching sessions with query '%s' (page=%d, size=%d)",
+        user_id,
+        query,
+        page_number,
+        page_size,
+    )
+
+    try:
+        pagination = PaginationParams(page_number=page_number, page_size=page_size)
+        paginated_response = session_service.search_sessions(
+            db, user_id, query, pagination, project_id=project_id
+        )
+
+        session_responses = []
+        for session_domain in paginated_response.data:
+            session_response = SessionResponse(
+                id=session_domain.id,
+                user_id=session_domain.user_id,
+                name=session_domain.name,
+                agent_id=session_domain.agent_id,
+                project_id=session_domain.project_id,
+                project_name=session_domain.project_name,
+                created_time=session_domain.created_time,
+                updated_time=session_domain.updated_time,
+            )
+            session_responses.append(session_response)
+
+        return PaginatedResponse(data=session_responses, meta=paginated_response.meta)
+
+    except ValueError as e:
+        log.warning("Validation error searching sessions: %s", e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+        ) from e
+    except Exception as e:
+        log.error("Error searching sessions for user %s: %s", user_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to search sessions",
+        ) from e
+
+
 @router.get("/sessions/{session_id}", response_model=DataResponse[SessionResponse])
 async def get_session(
     session_id: str,
@@ -95,6 +162,7 @@ async def get_session(
             user_id=session_domain.user_id,
             name=session_domain.name,
             agent_id=session_domain.agent_id,
+            project_id=session_domain.project_id,
             created_time=session_domain.created_time,
             updated_time=session_domain.updated_time,
         )
@@ -399,6 +467,7 @@ async def update_session_name(
             user_id=updated_domain.user_id,
             name=updated_domain.name,
             agent_id=updated_domain.agent_id,
+            project_id=updated_domain.project_id,
             created_time=updated_domain.created_time,
             updated_time=updated_domain.updated_time,
         )
@@ -430,8 +499,11 @@ async def delete_session(
     user: dict = Depends(get_current_user),
     session_service: SessionService = Depends(get_session_business_service),
 ):
+    """
+    Soft delete a session (marks as deleted without removing from database).
+    """
     user_id = user.get("id")
-    log.info("User %s attempting to delete session %s", user_id, session_id)
+    log.info("User %s attempting to soft delete session %s", user_id, session_id)
 
     try:
         if (
@@ -452,7 +524,7 @@ async def delete_session(
                 status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
             )
 
-        log.info("Session %s deleted successfully", session_id)
+        log.info("Session %s soft deleted successfully", session_id)
 
     except HTTPException:
         raise
@@ -472,3 +544,82 @@ async def delete_session(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to delete session",
         ) from e
+
+
+@router.patch("/sessions/{session_id}/project", response_model=SessionResponse)
+async def move_session_to_project(
+    session_id: str,
+    request: MoveSessionRequest,
+    db: Session = Depends(get_db),
+    user: dict = Depends(get_current_user),
+    session_service: SessionService = Depends(get_session_business_service),
+):
+    """
+    Move a session to a different project or remove from project.
+    """
+    user_id = user.get("id")
+    log.info(
+        "User %s attempting to move session %s to project %s",
+        user_id,
+        session_id,
+        request.project_id,
+    )
+
+    try:
+        if (
+            not session_id
+            or session_id.strip() == ""
+            or session_id in ["null", "undefined"]
+        ):
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
+            )
+
+        updated_session = session_service.move_session_to_project(
+            db=db,
+            session_id=session_id,
+            user_id=user_id,
+            new_project_id=request.project_id,
+        )
+
+        if not updated_session:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail=SESSION_NOT_FOUND_MSG
+            )
+
+        log.info(
+            "Session %s moved to project %s successfully",
+            session_id,
+            request.project_id or "None",
+        )
+
+        return SessionResponse(
+            id=updated_session.id,
+            user_id=updated_session.user_id,
+            name=updated_session.name,
+            agent_id=updated_session.agent_id,
+            project_id=updated_session.project_id,
+            created_time=updated_session.created_time,
+            updated_time=updated_session.updated_time,
+        )
+
+    except HTTPException:
+        raise
+    except ValueError as e:
+        log.warning("Validation error moving session %s: %s", session_id, e)
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, detail=str(e)
+        ) from e
+    except Exception as e:
+        log.error(
+            "Error moving session %s for user %s: %s",
+            session_id,
+            user_id,
+            e,
+        )
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to move session",
+        ) from e
+
+

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -3,7 +3,7 @@ API Router for submitting and managing tasks to agents.
 """
 
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING
 
 import yaml
@@ -18,9 +18,18 @@ from fastapi import APIRouter, Depends, HTTPException, Response, status
 from fastapi import Request as FastAPIRequest
 from sqlalchemy.orm import Session as DBSession
 
+from ....gateway.http_sse.services.project_service import ProjectService
+
+from ....agent.utils.artifact_helpers import (
+    get_artifact_info_list,
+    load_artifact_content_or_metadata,
+    save_artifact_with_metadata,
+)
+
 from ....common import a2a
 from ....gateway.http_sse.dependencies import (
     get_db,
+    get_project_service_optional,
     get_sac_component,
     get_session_business_service,
     get_session_manager,
@@ -46,20 +55,231 @@ router = APIRouter()
 log = logging.getLogger(__name__)
 
 
+async def _inject_project_context(
+    project_id: str,
+    message_text: str,
+    user_id: str,
+    session_id: str,
+    project_service: ProjectService,
+    component: "WebUIBackendComponent",
+    log_prefix: str,
+    inject_full_context: bool = True,
+) -> str:
+    """
+    Helper function to inject project context and copy artifacts to session.
+
+    Args:
+        inject_full_context: If True, injects full project context (name, description, instructions).
+                           If False, only copies new artifacts without modifying message text.
+                           This allows existing sessions to get new project files without
+                           re-injecting the full context on every message.
+
+    Returns the modified message text with project context injected (if inject_full_context=True).
+    """
+    if not project_id or not message_text:
+        return message_text
+
+    from ....gateway.http_sse.dependencies import SessionLocal
+
+    if SessionLocal is None:
+        log.warning("%sProject context injection skipped: database not configured", log_prefix)
+        return message_text
+
+    db = SessionLocal()
+    try:
+        project = project_service.get_project(db, project_id, user_id)
+        if not project:
+            return message_text
+        
+        context_parts = []
+
+        # Only inject full context for new sessions
+        if inject_full_context:
+            # Start with clear workspace framing
+            context_parts.append(f'You are working in the project workspace: "{project.name}"')
+
+            # Add system prompt if exists
+            if project.system_prompt and project.system_prompt.strip():
+                context_parts.append(f"\n{project.system_prompt.strip()}")
+
+            # Add project description if exists
+            if project.description and project.description.strip():
+                context_parts.append(f"\nProject Description: {project.description.strip()}")
+        
+        # Always copy project artifacts to session (for both new and existing sessions)
+        # This ensures new project files are available to existing sessions
+        artifact_service = component.get_shared_artifact_service()
+        if artifact_service:
+            try:
+                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)
+                
+                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 project_artifacts:
+                    log.info("%sFound %d artifacts in project %s to process.", log_prefix, len(project_artifacts), project.id)
+                    
+                    # Get list of artifacts already in session to avoid re-copying
+                    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()
+                    
+                    all_artifact_descriptions = []  # For new sessions - all files
+                    new_artifact_descriptions = []  # For existing sessions - only new files
+                    artifacts_copied = 0
+                    
+                    for artifact_info in project_artifacts:
+                        # Build description for all artifacts (for new sessions)
+                        desc_str = f"- {artifact_info.filename}"
+                        if artifact_info.description:
+                            desc_str += f": {artifact_info.description}"
+                        all_artifact_descriptions.append(desc_str)
+
+                        # Skip if artifact already exists in session (any source)
+                        if artifact_info.filename in session_artifact_names:
+                            log.debug("%sSkipping artifact %s - already exists in session", log_prefix, artifact_info.filename)
+                            continue
+                        
+                        # Track new artifacts for existing sessions
+                        new_artifact_descriptions.append(desc_str)
+
+                        log.info("%sCopying new 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 {}
+                                
+                                # Ensure the source is always set for copied project artifacts
+                                full_metadata["source"] = "project"
+
+                                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)
+                            # Continue with other artifacts even if one fails
+
+                    # Add artifact descriptions to context
+                    if inject_full_context and all_artifact_descriptions:
+                        # New session: show all project files
+                        artifacts_context = (
+                            "\nFiles in Session:\n"
+                            "The following files are available in your session and can be viewed using your tools if required:\n"
+                            + "\n".join(all_artifact_descriptions)
+                        )
+                        context_parts.append(artifacts_context)
+                    elif not inject_full_context and new_artifact_descriptions:
+                        # Existing session: notify about newly added files
+                        new_files_context = (
+                            "\nNew Files Added to Project:\n"
+                            "The following files have been added to the project and are now available in your session:\n"
+                            + "\n".join(new_artifact_descriptions)
+                        )
+                        context_parts.append(new_files_context)
+                    
+                    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)
+                else:
+                    log.info("%sNo artifacts found in project %s to copy.", log_prefix, project.id)
+
+            except Exception as e:
+                log.warning("%sFailed to copy project artifacts to session: %s", log_prefix, e)
+                # Do not fail the entire request, just log the warning
+
+        # Inject all gathered context into the message, ending with user query
+        # Only modify message text if we're injecting full context (new sessions)
+        modified_message_text = message_text
+        if context_parts:
+            project_context = "\n".join(context_parts)
+            modified_message_text = f"{project_context}\n\nUSER QUERY:\n{message_text}"
+            log.info("%sInjected full project context for project: %s", log_prefix, project_id)
+        else:
+            log.debug("%sSkipped full context injection for existing session, but ensured new artifacts are copied", log_prefix)
+                
+        return modified_message_text
+
+    except Exception as e:
+        log.warning("%sFailed to inject project context: %s", log_prefix, e)
+        # Continue without injection - don't fail the request
+        return message_text
+    finally:
+        db.close()
+
+
 async def _submit_task(
     request: FastAPIRequest,
     payload: SendMessageRequest | SendStreamingMessageRequest,
     session_manager: SessionManager,
     component: "WebUIBackendComponent",
+    project_service: ProjectService | None,
     is_streaming: bool,
     session_service: SessionService | None = None,
 ):
-    """Helper to submit a task, handling both streaming and non-streaming cases."""
+    """
+    Helper to submit a task, handling both streaming and non-streaming cases.
+
+    Also handles project context injection.
+    """
     log_prefix = f"[POST /api/v1/message:{'stream' if is_streaming else 'send'}] "
 
     agent_name = None
+    project_id = None
     if payload.params and payload.params.message and payload.params.message.metadata:
         agent_name = payload.params.message.metadata.get("agent_name")
+        project_id = payload.params.message.metadata.get("project_id")
 
     if not agent_name:
         raise HTTPException(
@@ -99,6 +319,21 @@ async def _submit_task(
         user_id = user_identity.get("id")
         from ....gateway.http_sse.dependencies import SessionLocal
 
+        # If project_id not in metadata, check if session has a project_id in database
+        # This handles cases where sessions are moved to projects after creation
+        if not project_id and session_service and frontend_session_id:
+            if SessionLocal is not None:
+                db = SessionLocal()
+                try:
+                    session_details = session_service.get_session_details(db, frontend_session_id, user_id)
+                    if session_details and session_details.project_id:
+                        project_id = session_details.project_id
+                        log.info("%sFound project_id %s from session database for session %s", log_prefix, project_id, frontend_session_id)
+                except Exception as e:
+                    log.warning("%sFailed to lookup session project_id: %s", log_prefix, e)
+                finally:
+                    db.close()
+
         if frontend_session_id:
             session_id = frontend_session_id
             log.info(
@@ -123,6 +358,7 @@ async def _submit_task(
                         user_id=user_id,
                         agent_id=agent_name,
                         session_id=session_id,
+                        project_id=project_id,
                     )
                     db.commit()
                     log.debug(
@@ -140,8 +376,60 @@ async def _submit_task(
             "%sUsing ClientID: %s, SessionID: %s", log_prefix, client_id, session_id
         )
 
-        # Use the helper to get the unwrapped parts from the incoming message.
-        a2a_parts = a2a.get_parts_from_message(payload.params.message)
+        # Extract message text and apply project context injection
+        message_text = ""
+        if payload.params and payload.params.message:
+            parts = a2a.get_parts_from_message(payload.params.message)
+            for part in parts:
+                if hasattr(part, "text"):
+                    message_text = part.text
+                    break
+        
+        # Project context injection - always inject for project sessions to ensure new files are available
+        # Skip if project_service is None (persistence disabled)
+        modified_message = payload.params.message
+        if project_service and project_id and message_text:
+            # Inject context for new sessions (includes full context + artifact copy)
+            # For existing sessions, only copy new artifacts without re-injecting full context
+            should_inject_full_context = not frontend_session_id
+
+            modified_message_text = await _inject_project_context(
+                project_id=project_id,
+                message_text=message_text,
+                user_id=user_id,
+                session_id=session_id,
+                project_service=project_service,
+                component=component,
+                log_prefix=log_prefix,
+                inject_full_context=should_inject_full_context,
+            )
+
+            # Update the message with project context if it was modified
+            if modified_message_text != message_text:
+                # Create new text part with project context
+                new_text_part = a2a.create_text_part(modified_message_text)
+
+                # Get existing parts and replace the first text part with the modified one
+                existing_parts = a2a.get_parts_from_message(payload.params.message)
+                new_parts = []
+                text_part_replaced = False
+
+                for part in existing_parts:
+                    if hasattr(part, "text") and not text_part_replaced:
+                        new_parts.append(new_text_part)
+                        text_part_replaced = True
+                    else:
+                        new_parts.append(part)
+
+                # If no text part was found, add the new text part at the beginning
+                if not text_part_replaced:
+                    new_parts.insert(0, new_text_part)
+
+                # Update the message with the new parts
+                modified_message = a2a.update_message_parts(payload.params.message, new_parts)
+
+        # Use the helper to get the unwrapped parts from the modified message (with project context if applied).
+        a2a_parts = a2a.get_parts_from_message(modified_message)
 
         external_req_ctx = {
             "app_name_for_artifacts": component.gateway_id,
@@ -341,6 +629,7 @@ async def send_task_to_agent(
     payload: SendMessageRequest,
     session_manager: SessionManager = Depends(get_session_manager),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
+    project_service: ProjectService | None = Depends(get_project_service_optional),
 ):
     """
     Submits a non-streaming task request to the specified agent.
@@ -351,6 +640,7 @@ async def send_task_to_agent(
         payload=payload,
         session_manager=session_manager,
         component=component,
+        project_service=project_service,
         is_streaming=False,
         session_service=None,
     )
@@ -362,6 +652,7 @@ async def subscribe_task_from_agent(
     payload: SendStreamingMessageRequest,
     session_manager: SessionManager = Depends(get_session_manager),
     component: "WebUIBackendComponent" = Depends(get_sac_component),
+    project_service: ProjectService | None = Depends(get_project_service_optional),
     session_service: SessionService = Depends(get_session_business_service),
 ):
     """
@@ -374,6 +665,7 @@ async def subscribe_task_from_agent(
         payload=payload,
         session_manager=session_manager,
         component=component,
+        project_service=project_service,
         is_streaming=True,
         session_service=session_service,
     )