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

solace_agent_mesh/gateway/http_sse/services/prompt_builder_assistant.py

@@ -0,0 +1,303 @@
+"""
+AI Assistant for Prompt Template Builder.
+Manages conversational prompt template creation through natural language.
+"""
+
+import json
+import logging
+import os
+import re
+from typing import Dict, Any, List, Optional
+from pydantic import BaseModel, Field
+from litellm import acompletion
+from sqlalchemy.orm import Session
+
+logger = logging.getLogger(__name__)
+
+
+class PromptBuilderResponse(BaseModel):
+    """Response from the prompt builder assistant."""
+    message: str
+    template_updates: Dict[str, Any] = Field(default_factory=dict)
+    confidence: float = Field(ge=0.0, le=1.0)
+    ready_to_save: bool = False
+
+
+class PromptBuilderAssistant:
+    """
+    AI assistant for prompt template creation.
+    Manages conversation flow and template generation.
+    """
+    
+    SYSTEM_PROMPT = """You are an AI assistant helping users create reusable prompt templates.
+
+CRITICAL RULES:
+1. You MUST respond with valid JSON in this exact format - NO EXCEPTIONS
+2. You MUST always include a "message" field with a helpful, conversational response
+3. NEVER respond with just "I understand" - always provide actionable guidance
+4. ONLY create placeholders for DATA that changes (names, paths, dates, numbers, specific values)
+5. Keep instructions, steps, requirements, and process descriptions as FIXED TEXT
+6. Use descriptive variable names in Title Case (e.g., {{File Path}}, {{Module Name}})
+7. Suggest appropriate categories (Development, Analysis, Documentation, Communication, Testing, etc.)
+8. Generate short command names (lowercase, hyphens only)
+
+RESPONSE FORMAT (REQUIRED):
+{{
+  "message": "your conversational response here - MUST be helpful and specific",
+  "template_updates": {{
+    "name": "Name",
+    "category": "Category",
+    "command": "command-name",
+    "promptText": "Template with {{placeholders}} for variable data only",
+    "description": "Brief description"
+  }},
+  "confidence": 0.0-1.0,
+  "ready_to_save": false
+}}
+
+VARIABLE PLACEHOLDER RULES:
+- Use {{Variable Name}} format for placeholders (Title Case with spaces)
+- ONLY for data that changes: file paths, names, dates, numbers, specific values
+- NOT for instructions, steps, or requirements
+- Use descriptive names: {{File Path}}, {{Module Name}}, {{Task Description}}
+
+EXAMPLES:
+
+Example 1: Code Review Template
+User: "I need a template for code reviews"
+{{
+  "message": "Great! I'll create a code review template. What information changes each time you do a code review? For example: file path, module name, specific concerns?",
+  "template_updates": {{
+    "name": "Code Review Template",
+    "category": "Development"
+  }},
+  "confidence": 0.6,
+  "ready_to_save": false
+}}
+
+User: "The file path, module name, and specific security concerns"
+{{
+  "message": "Perfect! I've created a code review template with placeholders for file path, module name, and security concerns. Check the preview on the left!",
+  "template_updates": {{
+    "name": "Code Review Template",
+    "category": "Development",
+    "command": "code-review",
+    "promptText": "Review the {{Module Name}} module located at {{File Path}}.\\n\\nPlease perform a comprehensive code review focusing on:\\n1. Security vulnerabilities\\n2. Error handling\\n3. Code quality and best practices\\n4. Specific attention to: {{Security Concerns}}\\n\\nProvide a detailed report with:\\n- List of issues with severity levels\\n- Specific code snippets that need attention\\n- Recommendations for improvements",
+    "description": "Template for code review with security focus"
+  }},
+  "confidence": 0.9,
+  "ready_to_save": true
+}}
+
+Example 2: Bug Report Template
+User: "Create a bug report template"
+{{
+  "message": "I'll create a bug report template! What details vary for each bug report? For example: bug description, steps to reproduce, expected vs actual behavior?",
+  "template_updates": {{
+    "name": "Bug Report Template",
+    "category": "Testing"
+  }},
+  "confidence": 0.6,
+  "ready_to_save": false
+}}
+
+User: "Bug description, steps to reproduce, and environment details"
+{{
+  "message": "Excellent! I've created a bug report template with those placeholders. You can see it in the preview!",
+  "template_updates": {{
+    "name": "Bug Report Template",
+    "category": "Testing",
+    "command": "bug-report",
+    "promptText": "# Bug Report\\n\\n## Description\\n{{Bug Description}}\\n\\n## Steps to Reproduce\\n{{Steps To Reproduce}}\\n\\n## Environment\\n{{Environment Details}}\\n\\n## Expected Behavior\\nDescribe what should happen\\n\\n## Actual Behavior\\nDescribe what actually happens\\n\\n## Additional Context\\nAny other relevant information",
+    "description": "Template for reporting bugs with structured format"
+  }},
+  "confidence": 0.9,
+  "ready_to_save": true
+}}
+
+REMEMBER:
+- Ask clarifying questions to understand what data changes
+- Create detailed, useful templates
+- Only use placeholders for variable data
+- Keep instructions and structure as fixed text
+- Set ready_to_save to true when template is complete
+"""
+    
+    def __init__(self, db: Optional[Session] = None, model_config: Optional[Dict[str, Any]] = None):
+        """Initialize the assistant with model configuration from component config."""
+        self.system_prompt = self.SYSTEM_PROMPT
+        self.db = db
+        
+        # Get LLM configuration from provided config
+        if not model_config or not isinstance(model_config, dict):
+            raise ValueError("model_config is required and must be a dictionary")
+        
+        if not model_config.get("model"):
+            raise ValueError("model_config must contain 'model' key")
+        
+        self.model = model_config.get("model")
+        self.api_base = model_config.get("api_base")
+        self.api_key = model_config.get("api_key", "dummy")
+    
+    def _get_existing_commands(self, user_id: str) -> List[str]:
+        """Get list of existing command shortcuts to avoid conflicts."""
+        if not self.db:
+            return []
+        
+        try:
+            from ..repository.models import PromptGroupModel
+            
+            groups = self.db.query(PromptGroupModel).filter(
+                PromptGroupModel.user_id == user_id,
+                PromptGroupModel.command.isnot(None)
+            ).all()
+            
+            return [group.command for group in groups if group.command]
+        except Exception as e:
+            logger.error(f"Error fetching existing commands: {e}")
+            return []
+    
+    async def process_message(
+        self,
+        user_message: str,
+        conversation_history: List[Dict[str, str]],
+        current_template: Dict[str, Any],
+        user_id: Optional[str] = None
+    ) -> PromptBuilderResponse:
+        """
+        Process user message and update template using LLM.
+        
+        Args:
+            user_message: The user's message
+            conversation_history: Previous conversation messages
+            current_template: Current template configuration
+            
+        Returns:
+            PromptBuilderResponse with updates
+        """
+        try:
+            return await self._llm_response(
+                user_message,
+                conversation_history,
+                current_template,
+                user_id
+            )
+        except Exception as e:
+            logger.error(f"Error processing message: {e}", exc_info=True)
+            return PromptBuilderResponse(
+                message="I encountered an error. Could you please rephrase that?",
+                confidence=0.0,
+                ready_to_save=False
+            )
+    
+    async def _llm_response(
+        self,
+        user_message: str,
+        conversation_history: List[Dict[str, str]],
+        current_template: Dict[str, Any],
+        user_id: Optional[str] = None
+    ) -> PromptBuilderResponse:
+        """Use LLM to generate response and template updates."""
+        
+        # Get existing commands to avoid conflicts
+        existing_commands = []
+        if user_id and self.db:
+            existing_commands = self._get_existing_commands(user_id)
+        
+        # Build messages for LLM
+        messages = [
+            {"role": "system", "content": self.system_prompt}
+        ]
+        
+        # Add conversation history
+        messages.extend(conversation_history)
+        
+        # Add current message with template context and existing commands
+        template_context = f"\n\nCurrent Template:\n{json.dumps(current_template, indent=2)}"
+        
+        commands_context = ""
+        if existing_commands:
+            commands_context = f"\n\nEXISTING COMMANDS (avoid these):\n{', '.join(['/' + cmd for cmd in existing_commands])}"
+        
+        messages.append({
+            "role": "user",
+            "content": user_message + template_context + commands_context
+        })
+        
+        # Call LLM with JSON mode
+        try:
+            completion_args = {
+                "model": self.model,
+                "messages": messages,
+                "response_format": {"type": "json_object"},
+                "temperature": 0.1,  # Low temperature for consistency
+            }
+            
+            if self.api_base:
+                completion_args["api_base"] = self.api_base
+            if self.api_key:
+                completion_args["api_key"] = self.api_key
+            
+            response = await acompletion(**completion_args)
+            
+            # Parse response
+            content = response.choices[0].message.content
+            logger.info(f"LLM Response: {content}")
+            
+            try:
+                parsed = json.loads(content)
+            except json.JSONDecodeError as e:
+                logger.error(f"Failed to parse LLM response as JSON: {e}")
+                logger.error(f"Response content: {content}")
+                # Try to extract JSON from response
+                json_match = re.search(r'\{.*\}', content, re.DOTALL)
+                if json_match:
+                    parsed = json.loads(json_match.group())
+                else:
+                    raise
+            
+            # Handle nested response structure (some LLMs wrap in various keys)
+            if "response" in parsed and isinstance(parsed["response"], dict):
+                logger.info("Unwrapping nested 'response' structure from LLM")
+                parsed = parsed["response"]
+            
+            # Handle case where LLM wraps response in an arbitrary key (e.g., "{}", "result", etc.)
+            # If we don't have a "message" key but have exactly one key with a dict value containing "message"
+            if "message" not in parsed and len(parsed) == 1:
+                single_key = list(parsed.keys())[0]
+                if isinstance(parsed[single_key], dict) and "message" in parsed[single_key]:
+                    logger.info(f"Unwrapping nested structure from key '{single_key}'")
+                    parsed = parsed[single_key]
+            
+            # Validate that we have a proper message
+            message = parsed.get("message", "")
+            if not message or message.strip().lower() in ["i understand", "i understand.", "ok", "okay"]:
+                logger.warning(f"LLM returned generic/empty message: '{message}'")
+                message = "I'll help you create that template. Could you provide more details about what information changes each time you use this prompt?"
+            
+            return PromptBuilderResponse(
+                message=message,
+                template_updates=parsed.get("template_updates", {}),
+                confidence=parsed.get("confidence", 0.5),
+                ready_to_save=parsed.get("ready_to_save", False)
+            )
+            
+        except Exception as e:
+            logger.error(f"LLM call failed: {e}", exc_info=True)
+            # Fallback response with helpful guidance
+            return PromptBuilderResponse(
+                message="I'm having trouble processing that. Could you describe what you'd like this template to do? For example, what task are you trying to automate or what information changes each time?",
+                confidence=0.3,
+                ready_to_save=False
+            )
+    
+    def get_initial_greeting(self) -> PromptBuilderResponse:
+        """Get the initial greeting message."""
+        return PromptBuilderResponse(
+            message="Hi! I'll help you create a prompt template. You can either:\n\n"
+                   "1. Describe a recurring task you'd like to template\n"
+                   "2. Paste an example transcript of the task\n\n"
+                   "What would you like to create a template for?",
+            confidence=1.0,
+            ready_to_save=False
+        )

solace_agent_mesh/gateway/http_sse/services/session_service.py

@@ -9,11 +9,12 @@ from ..repository import (
     Session,
 )
 from ..repository.chat_task_repository import ChatTaskRepository
+from ..repository.task_repository import TaskRepository
 from ..repository.entities import ChatTask
-from ..shared.enums import SenderType
-from ..shared.types import SessionId, UserId
-from ..shared import now_epoch_ms
-from ..shared.pagination import PaginationParams, PaginatedResponse, get_pagination_or_default
+from solace_agent_mesh.shared.utils.enums import SenderType
+from solace_agent_mesh.shared.utils.types import SessionId, UserId
+from solace_agent_mesh.shared.utils.timestamp_utils import now_epoch_ms
+from solace_agent_mesh.shared.api.pagination import PaginationParams, PaginatedResponse, get_pagination_or_default
 
 log = logging.getLogger(__name__)
 
@@ -46,7 +47,7 @@ class SessionService:
         project_id: str | None = None
     ) -> PaginatedResponse[Session]:
         """
-        Get paginated sessions for a user with full metadata including project names.
+        Get paginated sessions for a user with full metadata including project names and background task status.
         Uses default pagination if none provided (page 1, size 20).
         Returns paginated response with pageNumber, pageSize, nextPage, totalPages, totalCount.
 
@@ -81,6 +82,63 @@ class SessionService:
                 if session.project_id:
                     session.project_name = project_map.get(session.project_id)
 
+        # Check for running background tasks in these sessions
+        task_repo = TaskRepository()
+        session_ids = [s.id for s in sessions]
+        
+        # Get all running background tasks for this user
+        running_bg_tasks = task_repo.find_background_tasks_by_status(db, status=None)
+        running_bg_tasks = [
+            task for task in running_bg_tasks
+            if task.status in [None, "running", "pending"] and task.end_time is None and task.user_id == user_id
+        ]
+        
+        log.info(f"[get_user_sessions] Found {len(running_bg_tasks)} running background tasks for user {user_id}")
+        
+        # Create a map of session_id -> has_running_background_task
+        # Query ChatTaskModel to find which sessions these tasks belong to
+        # Also filter out tasks that have been marked as completed in their metadata
+        from ..repository.models import ChatTaskModel
+        import json
+        session_task_map = {}
+        if running_bg_tasks:
+            task_ids = [task.id for task in running_bg_tasks]
+            log.info(f"[get_user_sessions] Looking up chat tasks for task IDs: {task_ids}")
+            
+            # Query chat tasks for these task IDs
+            chat_tasks = db.query(ChatTaskModel).filter(
+                ChatTaskModel.id.in_(task_ids),
+                ChatTaskModel.user_id == user_id
+            ).all()
+            
+            log.info(f"[get_user_sessions] Found {len(chat_tasks)} chat tasks")
+            
+            for chat_task in chat_tasks:
+                if chat_task.session_id:
+                    # Check if task metadata indicates completion
+                    is_completed = False
+                    if chat_task.task_metadata:
+                        try:
+                            metadata = json.loads(chat_task.task_metadata) if isinstance(chat_task.task_metadata, str) else chat_task.task_metadata
+                            task_status = metadata.get("status")
+                            is_completed = task_status in ["completed", "error", "failed"]
+                            log.info(f"[get_user_sessions] Task {chat_task.id} metadata status: {task_status}, is_completed: {is_completed}")
+                        except Exception as e:
+                            log.warning(f"[get_user_sessions] Failed to parse task metadata for {chat_task.id}: {e}")
+                    
+                    # Only mark session as having running task if task is not completed
+                    if not is_completed:
+                        session_task_map[chat_task.session_id] = True
+                        log.debug(f"[get_user_sessions] Session {chat_task.session_id} has running background task {chat_task.id}")
+                    else:
+                        log.debug(f"[get_user_sessions] Task {chat_task.id} is completed, not marking session as having running task")
+        
+        # Add background task status to sessions
+        for session in sessions:
+            session.has_running_background_task = session_task_map.get(session.id, False)
+            if session.has_running_background_task:
+                log.info(f"[get_user_sessions] Marking session {session.id} as having running background task")
+
         return PaginatedResponse.create(sessions, total_count, pagination)
 
     def get_session_details(
@@ -229,21 +287,24 @@ class SessionService:
         log.info("Session %s soft deleted successfully by user %s", session_id, user_id)
         return True
 
-    def move_session_to_project(
+    async def move_session_to_project(
         self, db: DbSession, session_id: SessionId, user_id: UserId, new_project_id: str | None
     ) -> Session | None:
         """
         Move a session to a different project.
-        
+
+        When moving to a project, this also copies all project artifacts to the session
+        so they are immediately available without waiting for the next user message.
+
         Args:
             db: Database session
             session_id: Session ID to move
             user_id: User ID performing the move
             new_project_id: New project ID (or None to remove from project)
-            
+
         Returns:
             Session: Updated session if successful, None otherwise
-            
+
         Raises:
             ValueError: If session or project validation fails
         """
@@ -258,13 +319,13 @@ class SessionService:
                 ProjectModel.user_id == user_id,
                 ProjectModel.deleted_at.is_(None)
             ).first()
-            
+
             if not project:
                 raise ValueError(f"Project {new_project_id} not found or access denied")
 
         session_repository = self._get_repositories(db)
         updated_session = session_repository.move_to_project(db, session_id, user_id, new_project_id)
-        
+
         if not updated_session:
             log.warning(
                 "Failed to move session %s to project %s for user %s",
@@ -274,12 +335,63 @@ class SessionService:
             )
             return None
 
-        log.info(
-            "Session %s moved to project %s by user %s",
-            session_id,
-            new_project_id or "None",
-            user_id,
-        )
+        try:
+            db.commit()
+            log.info(
+                "Session %s moved to project %s by user %s",
+                session_id,
+                new_project_id or "None",
+                user_id,
+            )
+        except Exception as e:
+            db.rollback()
+            log.error(
+                "Failed to commit session move for session %s: %s",
+                session_id,
+                e,
+            )
+            raise
+
+        # Copy project artifacts to session immediately when moving to a project
+        if new_project_id and self.component:
+            from ..utils.artifact_copy_utils import copy_project_artifacts_to_session
+            from ..services.project_service import ProjectService
+            from ..dependencies import SessionLocal
+
+            if SessionLocal:
+                artifact_db = SessionLocal()
+                try:
+                    project_service = ProjectService(component=self.component)
+                    log_prefix = f"[move_session_to_project session_id={session_id}] "
+
+                    artifacts_copied, _ = await copy_project_artifacts_to_session(
+                        project_id=new_project_id,
+                        user_id=user_id,
+                        session_id=session_id,
+                        project_service=project_service,
+                        component=self.component,
+                        db=artifact_db,
+                        log_prefix=log_prefix,
+                    )
+
+                    if artifacts_copied > 0:
+                        log.info(
+                            "%sCopied %d project artifacts to session during move",
+                            log_prefix,
+                            artifacts_copied,
+                        )
+                except Exception as e:
+                    # Don't fail the move operation if artifact copying fails
+                    # The session move has already been committed at this point
+                    log.warning(
+                        "Failed to copy project artifacts when moving session %s to project %s: %s",
+                        session_id,
+                        new_project_id,
+                        e,
+                    )
+                finally:
+                    artifact_db.close()
+
         return updated_session
 
     def search_sessions(
@@ -291,15 +403,15 @@ class SessionService:
         project_id: str | None = None
     ) -> PaginatedResponse[Session]:
         """
-        Search sessions by name or content.
-        
+        Search sessions by name/title only.
+
         Args:
             db: Database session
             user_id: User ID to filter sessions by
             query: Search query string
             pagination: Pagination parameters
             project_id: Optional project ID to filter sessions by
-            
+
         Returns:
             PaginatedResponse[Session]: Paginated search results
         """
@@ -328,6 +440,63 @@ class SessionService:
                 if session.project_id:
                     session.project_name = project_map.get(session.project_id)
 
+        # Check for running background tasks in these sessions
+        task_repo = TaskRepository()
+        session_ids = [s.id for s in sessions]
+        
+        # Get all running background tasks for this user
+        running_bg_tasks = task_repo.find_background_tasks_by_status(db, status=None)
+        running_bg_tasks = [
+            task for task in running_bg_tasks
+            if task.status in [None, "running", "pending"] and task.end_time is None and task.user_id == user_id
+        ]
+        
+        log.info(f"[search_sessions] Found {len(running_bg_tasks)} running background tasks for user {user_id}")
+        
+        # Create a map of session_id -> has_running_background_task
+        # Query ChatTaskModel to find which sessions these tasks belong to
+        # Also filter out tasks that have been marked as completed in their metadata
+        from ..repository.models import ChatTaskModel
+        import json
+        session_task_map = {}
+        if running_bg_tasks:
+            task_ids = [task.id for task in running_bg_tasks]
+            log.info(f"[search_sessions] Looking up chat tasks for task IDs: {task_ids}")
+            
+            # Query chat tasks for these task IDs
+            chat_tasks = db.query(ChatTaskModel).filter(
+                ChatTaskModel.id.in_(task_ids),
+                ChatTaskModel.user_id == user_id
+            ).all()
+            
+            log.info(f"[search_sessions] Found {len(chat_tasks)} chat tasks")
+            
+            for chat_task in chat_tasks:
+                if chat_task.session_id:
+                    # Check if task metadata indicates completion
+                    is_completed = False
+                    if chat_task.task_metadata:
+                        try:
+                            metadata = json.loads(chat_task.task_metadata) if isinstance(chat_task.task_metadata, str) else chat_task.task_metadata
+                            task_status = metadata.get("status")
+                            is_completed = task_status in ["completed", "error", "failed"]
+                            log.info(f"[search_sessions] Task {chat_task.id} metadata status: {task_status}, is_completed: {is_completed}")
+                        except Exception as e:
+                            log.warning(f"[search_sessions] Failed to parse task metadata for {chat_task.id}: {e}")
+                    
+                    # Only mark session as having running task if task is not completed
+                    if not is_completed:
+                        session_task_map[chat_task.session_id] = True
+                        log.info(f"[search_sessions] Session {chat_task.session_id} has running background task {chat_task.id}")
+                    else:
+                        log.info(f"[search_sessions] Task {chat_task.id} is completed, not marking session as having running task")
+        
+        # Add background task status to sessions
+        for session in sessions:
+            session.has_running_background_task = session_task_map.get(session.id, False)
+            if session.has_running_background_task:
+                log.info(f"[search_sessions] Marking session {session.id} as having running background task")
+
         log.info(
             "Search for '%s' by user %s returned %d results (total: %d)",
             query,
@@ -423,7 +592,15 @@ class SessionService:
 
         # Load tasks
         task_repo = ChatTaskRepository()
-        return task_repo.find_by_session(db, session_id, user_id)
+        tasks = task_repo.find_by_session(db, session_id, user_id)
+        
+        # Note: Deduplication logic was removed because the root cause of duplicate
+        # artifact markers has been fixed in task_logger_service.py. The fix ensures
+        # that when reconstructing chat messages for background tasks, existing
+        # versioned markers (e.g., «artifact_return:report.md:0») are properly
+        # detected and prevent adding duplicate non-versioned markers.
+        
+        return tasks
 
     def get_session_messages_from_tasks(
         self,