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

solace_agent_mesh/gateway/http_sse/routers/config.py

@@ -1,22 +1,145 @@
 """
 API Router for providing frontend configuration.
 """
+from __future__ import annotations
 
 import logging
-from fastapi import APIRouter, Depends, HTTPException, status
 from typing import Dict, Any
+from typing import TYPE_CHECKING
 
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from ..routers.dto.requests.project_requests import CreateProjectRequest
 from ....gateway.http_sse.dependencies import get_sac_component, get_api_config
-from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from gateway.http_sse.component import WebUIBackendComponent
+    from ..component import WebUIBackendComponent
 
 log = logging.getLogger(__name__)
 
 router = APIRouter()
 
 
+# Default max upload size (50MB) - matches gateway_max_upload_size_bytes default
+DEFAULT_MAX_UPLOAD_SIZE_BYTES = 52428800
+# Default max ZIP upload size (100MB) - for project import ZIP files
+DEFAULT_MAX_ZIP_UPLOAD_SIZE_BYTES = 104857600
+
+
+def _get_validation_limits(component: "WebUIBackendComponent" = None) -> Dict[str, Any]:
+    """
+    Extract validation limits from Pydantic models to expose to frontend.
+    This ensures frontend and backend validation limits stay in sync.
+    """
+    # Extract limits from CreateProjectRequest model
+    create_fields = CreateProjectRequest.model_fields
+    
+    # Get max upload size from component config, with fallback to default
+    max_upload_size_bytes = (
+        component.get_config("gateway_max_upload_size_bytes", DEFAULT_MAX_UPLOAD_SIZE_BYTES)
+        if component else DEFAULT_MAX_UPLOAD_SIZE_BYTES
+    )
+    
+    # Get max ZIP upload size from component config, with fallback to default (100MB)
+    max_zip_upload_size_bytes = (
+        component.get_config("gateway_max_zip_upload_size_bytes", DEFAULT_MAX_ZIP_UPLOAD_SIZE_BYTES)
+        if component else DEFAULT_MAX_ZIP_UPLOAD_SIZE_BYTES
+    )
+    
+    return {
+        "projectNameMax": create_fields["name"].metadata[1].max_length if create_fields["name"].metadata else 255,
+        "projectDescriptionMax": create_fields["description"].metadata[0].max_length if create_fields["description"].metadata else 1000,
+        "projectInstructionsMax": create_fields["system_prompt"].metadata[0].max_length if create_fields["system_prompt"].metadata else 4000,
+        "maxUploadSizeBytes": max_upload_size_bytes,
+        "maxZipUploadSizeBytes": max_zip_upload_size_bytes,
+    }
+
+
+def _get_background_tasks_config(
+    component: "WebUIBackendComponent",
+    log_prefix: str
+) -> Dict[str, Any]:
+    """
+    Extracts background tasks configuration for the frontend.
+    
+    Returns:
+        Dict with background tasks non-boolean settings:
+        - default_timeout_ms: Default timeout for background tasks
+        
+    Note: The 'enabled' flag is now in frontend_feature_enablement.background_tasks
+    """
+    background_config = component.get_config("background_tasks", {})
+    default_timeout_ms = background_config.get("default_timeout_ms", 3600000)  # 1 hour default
+    
+    return {
+        "default_timeout_ms": default_timeout_ms,
+    }
+
+
+def _determine_background_tasks_enabled(
+    component: "WebUIBackendComponent",
+    log_prefix: str
+) -> bool:
+    """
+    Determines if background tasks feature should be enabled.
+    
+    Returns:
+        bool: True if background tasks should be enabled
+    """
+    feature_flags = component.get_config("frontend_feature_enablement", {})
+    enabled = feature_flags.get("background_tasks", False)
+    
+    if enabled:
+        log.debug("%s Background tasks enabled globally for all agents", log_prefix)
+    else:
+        log.debug("%s Background tasks disabled", log_prefix)
+    
+    return enabled
+
+
+def _determine_projects_enabled(
+    component: "WebUIBackendComponent",
+    api_config: Dict[str, Any],
+    log_prefix: str
+) -> bool:
+    """
+    Determines if projects feature should be enabled.
+    
+    Logic:
+    1. Check if persistence is enabled (required for projects)
+    2. Check explicit projects.enabled config
+    3. Check frontend_feature_enablement.projects override
+    
+    Returns:
+        bool: True if projects should be enabled
+    """
+    # Projects require persistence
+    persistence_enabled = api_config.get("persistence_enabled", False)
+    if not persistence_enabled:
+        log.debug("%s Projects disabled: persistence is not enabled", log_prefix)
+        return False
+    
+    # Check explicit projects config
+    projects_config = component.get_config("projects", {})
+    if isinstance(projects_config, dict):
+        projects_explicitly_enabled = projects_config.get("enabled", True)
+        if not projects_explicitly_enabled:
+            log.debug("%s Projects disabled: explicitly disabled in config", log_prefix)
+            return False
+    
+    # Check frontend_feature_enablement override
+    feature_flags = component.get_config("frontend_feature_enablement", {})
+    if "projects" in feature_flags:
+        projects_flag = feature_flags.get("projects", True)
+        if not projects_flag:
+            log.debug("%s Projects disabled: disabled in frontend_feature_enablement", log_prefix)
+            return False
+    
+    # All checks passed
+    log.debug("%s Projects enabled: persistence enabled and no explicit disable", log_prefix)
+    return True
+
+
 @router.get("/config", response_model=Dict[str, Any])
 async def get_app_config(
     component: "WebUIBackendComponent" = Depends(get_sac_component),
@@ -37,6 +160,80 @@ async def get_app_config(
             feature_enablement["taskLogging"] = True
             log.debug("%s taskLogging feature flag is enabled.", log_prefix)
 
+        # Determine if prompt library should be enabled
+        # Prompts require SQL session storage for persistence
+        prompt_library_config = component.get_config("prompt_library", {})
+        prompt_library_explicitly_enabled = prompt_library_config.get("enabled", True)
+        
+        if prompt_library_explicitly_enabled:
+            # Check if SQL persistence is available (REQUIRED for prompts)
+            session_config = component.get_config("session_service", {})
+            session_type = session_config.get("type", "memory")
+            
+            if session_type != "sql":
+                log.warning(
+                    "%s Prompt library is configured but session_service type is '%s' (not 'sql'). "
+                    "Disabling prompt library for frontend.",
+                    log_prefix,
+                    session_type
+                )
+                prompt_library_enabled = False
+            else:
+                prompt_library_enabled = True
+                feature_enablement["promptLibrary"] = True
+                log.debug("%s promptLibrary feature flag is enabled.", log_prefix)
+                
+                # Check AI-assisted sub-feature (only if parent is enabled)
+                ai_assisted_config = prompt_library_config.get("ai_assisted", {})
+                ai_assisted_enabled = ai_assisted_config.get("enabled", True)
+                
+                if ai_assisted_enabled:
+                    # Verify LLM is configured through the model config
+                    model_config = component.get_config("model", {})
+                    
+                    llm_model = None
+                    if isinstance(model_config, dict):
+                        llm_model = model_config.get("model")
+                    
+                    if llm_model:
+                        feature_enablement["promptAIAssisted"] = True
+                        log.debug("%s promptAIAssisted feature flag is enabled.", log_prefix)
+                    else:
+                        feature_enablement["promptAIAssisted"] = False
+                        log.warning(
+                            "%s AI-assisted prompts disabled: model not configured",
+                            log_prefix
+                        )
+                else:
+                    feature_enablement["promptAIAssisted"] = False
+                
+                # Check version history sub-feature (only if parent is enabled)
+                version_history_config = prompt_library_config.get("version_history", {})
+                version_history_enabled = version_history_config.get("enabled", True)
+                
+                if version_history_enabled:
+                    feature_enablement["promptVersionHistory"] = True
+                    log.debug("%s promptVersionHistory feature flag is enabled.", log_prefix)
+                else:
+                    feature_enablement["promptVersionHistory"] = False
+                
+                # Check prompt sharing sub-feature (only if parent is enabled)
+                sharing_config = prompt_library_config.get("sharing", {})
+                sharing_enabled = sharing_config.get("enabled", False)
+                
+                if sharing_enabled:
+                    feature_enablement["promptSharing"] = True
+                    log.debug("%s promptSharing feature flag is enabled.", log_prefix)
+                else:
+                    feature_enablement["promptSharing"] = False
+        else:
+            # Explicitly set to false when disabled
+            feature_enablement["promptLibrary"] = False
+            feature_enablement["promptAIAssisted"] = False
+            feature_enablement["promptVersionHistory"] = False
+            feature_enablement["promptSharing"] = False
+            log.info("%s Prompt library feature is explicitly disabled.", log_prefix)
+
         # Determine if feedback should be enabled
         # Feedback requires SQL session storage for persistence
         feedback_enabled = component.get_config("frontend_collect_feedback", False)
@@ -51,25 +248,122 @@ async def get_app_config(
                     session_type
                 )
                 feedback_enabled = False
+        
+        # Determine if projects should be enabled
+        # Projects require SQL session storage for persistence
+        projects_enabled = _determine_projects_enabled(component, api_config, log_prefix)
+        feature_enablement["projects"] = projects_enabled
+        if projects_enabled:
+            log.debug("%s Projects feature flag is enabled.", log_prefix)
+        else:
+            log.debug("%s Projects feature flag is disabled.", log_prefix)
+        
+        
+        # Determine if background tasks should be enabled
+        background_tasks_enabled = _determine_background_tasks_enabled(component, log_prefix)
+        feature_enablement["background_tasks"] = background_tasks_enabled
+        if background_tasks_enabled:
+            log.debug("%s Background tasks feature flag is enabled.", log_prefix)
+        else:
+            log.debug("%s Background tasks feature flag is disabled.", log_prefix)
+        
+        # Check tool configuration status
+        tool_config_status = {}
+        
+        # Check TTS configuration from component config (not environment variables)
+        speech_config = component.get_config("speech", {})
+        tts_config = speech_config.get("tts", {})
+        
+        # Check if speech/TTS section is defined in config
+        # If not defined, disable TTS even if keys might be present elsewhere
+        if not speech_config or not tts_config:
+            log.debug("%s TTS disabled: speech.tts section not configured", log_prefix)
+            tts_configured = False
+            tts_provider = "gemini"  # Default fallback
+        else:
+            # Get provider from config (with fallback to default)
+            preferred_provider = tts_config.get("provider", "gemini").lower()
+            
+            # Check which providers are configured
+            gemini_config = tts_config.get("gemini", {})
+            azure_config = tts_config.get("azure", {})
+            polly_config = tts_config.get("polly", {})
+            
+            gemini_key = gemini_config.get("api_key")
+            azure_speech_key = azure_config.get("api_key")
+            azure_speech_region = azure_config.get("region")
+            aws_access_key = polly_config.get("aws_access_key_id")
+            aws_secret_key = polly_config.get("aws_secret_access_key")
+            
+            # Determine which providers are available
+            gemini_available = bool(gemini_key)
+            azure_available = bool(azure_speech_key and azure_speech_region)
+            polly_available = bool(aws_access_key and aws_secret_key)
+            tts_configured = gemini_available or azure_available or polly_available
+            tool_config_status["text_to_speech"] = tts_configured
+            
+            # Determine TTS provider based on preference and availability
+            if preferred_provider == "azure" and azure_available:
+                tts_provider = "azure"
+            elif preferred_provider == "gemini" and gemini_available:
+                tts_provider = "gemini"
+            elif preferred_provider == "polly" and polly_available:
+                tts_provider = "polly"
+            elif gemini_available:
+                # Default to Gemini if available
+                tts_provider = "gemini"
+            elif azure_available:
+                # Fall back to Azure if Gemini not available
+                tts_provider = "azure"
+            elif polly_available:
+                # Fall back to Polly if others not available
+                tts_provider = "polly"
+            else:
+                # No provider available, default to gemini (will use browser fallback)
+                tts_provider = "gemini"
+            
+            if tts_configured:
+                log.debug("%s TTS is configured (API keys present, provider: %s)", log_prefix, tts_provider)
+                if preferred_provider and preferred_provider != tts_provider:
+                    log.warning(
+                        "%s TTS_PROVIDER set to '%s' but using '%s' (preferred provider not available)",
+                        log_prefix, preferred_provider, tts_provider
+                    )
+            else:
+                log.debug("%s TTS not configured (no API keys found)", log_prefix)
+        
+        # TTS settings - enable if API keys are present
+        tts_settings = {
+            "textToSpeech": tts_configured,
+            "engineTTS": "external" if tts_configured else "browser",
+            "ttsProvider": tts_provider,
+        }
+
+        platform_config = component.get_config("platform_service", {})
+        platform_service_url = platform_config.get("url", "")
 
         config_data = {
-            "frontend_server_url": "",
+            "frontend_server_url": component.frontend_server_url,
+            "frontend_platform_server_url": platform_service_url,
             "frontend_auth_login_url": component.get_config(
                 "frontend_auth_login_url", ""
             ),
-            "frontend_use_authorization": component.get_config(
-                "frontend_use_authorization", False
-            ),
+            "frontend_use_authorization": component.get_config("frontend_use_authorization", False),
             "frontend_welcome_message": component.get_config(
                 "frontend_welcome_message", ""
             ),
             "frontend_redirect_url": component.get_config("frontend_redirect_url", ""),
             "frontend_collect_feedback": feedback_enabled,
             "frontend_bot_name": component.get_config("frontend_bot_name", "A2A Agent"),
+            "frontend_logo_url": component.get_config("frontend_logo_url", ""),
             "frontend_feature_enablement": feature_enablement,
             "persistence_enabled": api_config.get("persistence_enabled", False),
+            "validation_limits": _get_validation_limits(component),
+            "tool_config_status": tool_config_status,
+            "tts_settings": tts_settings,
+            "background_tasks_config": _get_background_tasks_config(component, log_prefix),
         }
-        log.info("%sReturning frontend configuration.", log_prefix)
+        log.debug("%sReturning frontend configuration.", log_prefix)
         return config_data
     except Exception as e:
         log.exception(

solace_agent_mesh/gateway/http_sse/routers/dto/project_dto.py

@@ -0,0 +1,69 @@
+"""
+Project export/import DTOs.
+"""
+
+from typing import Optional, List, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class ArtifactMetadata(BaseModel):
+    """Metadata for an artifact in export"""
+    filename: str
+    mime_type: str = Field(alias="mimeType")
+    size: int
+    metadata: Dict[str, Any] = {}
+    
+    model_config = {"populate_by_name": True}
+
+
+class ProjectExportMetadata(BaseModel):
+    """Metadata for exported project"""
+    original_created_at: int = Field(alias="originalCreatedAt")
+    artifact_count: int = Field(alias="artifactCount")
+    total_size_bytes: int = Field(alias="totalSizeBytes")
+    
+    model_config = {"populate_by_name": True}
+
+
+class ProjectExportData(BaseModel):
+    """Project data in export format"""
+    name: str
+    description: Optional[str] = None
+    system_prompt: Optional[str] = Field(default=None, alias="systemPrompt")
+    default_agent_id: Optional[str] = Field(default=None, alias="defaultAgentId")
+    metadata: ProjectExportMetadata
+    
+    model_config = {"populate_by_name": True}
+
+
+class ProjectExportFormat(BaseModel):
+    """Complete export format"""
+    version: str = "1.0"
+    exported_at: int = Field(alias="exportedAt")
+    project: ProjectExportData
+    artifacts: List[ArtifactMetadata] = []
+    
+    model_config = {"populate_by_name": True}
+
+
+class ProjectImportOptions(BaseModel):
+    """Options for project import"""
+    preserve_name: bool = Field(default=False, alias="preserveName")
+    custom_name: Optional[str] = Field(default=None, alias="customName")
+    
+    model_config = {"populate_by_name": True}
+
+
+class ProjectImportRequest(BaseModel):
+    """Request for importing project"""
+    options: ProjectImportOptions
+
+
+class ProjectImportResponse(BaseModel):
+    """Response after importing project"""
+    project_id: str = Field(alias="projectId")
+    name: str
+    artifacts_imported: int = Field(alias="artifactsImported")
+    warnings: List[str] = []
+    
+    model_config = {"populate_by_name": True}

solace_agent_mesh/gateway/http_sse/routers/dto/prompt_dto.py

@@ -0,0 +1,255 @@
+"""
+Pydantic models for prompt library API.
+"""
+
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class PromptBase(BaseModel):
+    """Base schema for Prompt"""
+    prompt_text: str = Field(
+        ...,
+        min_length=1,
+        max_length=10000,
+        description="The prompt text content",
+        alias="promptText"
+    )
+    
+    class Config:
+        populate_by_name = True
+
+
+class PromptCreate(PromptBase):
+    """Schema for creating a new prompt version"""
+    pass
+
+
+class PromptResponse(PromptBase):
+    """Schema for prompt response"""
+    id: str
+    group_id: str = Field(alias="groupId")
+    user_id: str = Field(alias="userId")
+    version: int
+    # Versioned metadata fields
+    name: Optional[str] = Field(None, description="Prompt name at this version")
+    description: Optional[str] = Field(None, description="Prompt description at this version")
+    category: Optional[str] = Field(None, description="Prompt category at this version")
+    command: Optional[str] = Field(None, description="Prompt command at this version")
+    created_at: int = Field(alias="createdAt")  # epoch milliseconds
+    updated_at: int = Field(alias="updatedAt")  # epoch milliseconds
+    
+    class Config:
+        from_attributes = True
+        populate_by_name = True
+
+
+class PromptGroupBase(BaseModel):
+    """Base schema for PromptGroup"""
+    name: str = Field(
+        ..., 
+        min_length=1, 
+        max_length=255, 
+        description="Name of the prompt group"
+    )
+    description: Optional[str] = Field(
+        None, 
+        max_length=1000, 
+        description="Short description"
+    )
+    category: Optional[str] = Field(
+        None, 
+        max_length=100, 
+        description="Category for organization"
+    )
+    command: Optional[str] = Field(
+        None,
+        min_length=1,
+        max_length=50,
+        pattern="^[a-zA-Z0-9_-]+$",
+        description="Shorthand command (alphanumeric, dash, underscore only)"
+    )
+
+
+class PromptGroupCreate(PromptGroupBase):
+    """Schema for creating a new prompt group"""
+    initial_prompt: str = Field(
+        ..., 
+        min_length=1, 
+        max_length=10000, 
+        description="Initial prompt text"
+    )
+
+
+class PromptGroupUpdate(BaseModel):
+    """Schema for updating a prompt group"""
+    name: Optional[str] = Field(None, min_length=1, max_length=255)
+    description: Optional[str] = Field(None, max_length=1000)
+    category: Optional[str] = Field(None, max_length=100)
+    command: Optional[str] = Field(
+        None,
+        min_length=1,
+        max_length=50,
+        pattern="^[a-zA-Z0-9_-]+$"
+    )
+    initial_prompt: Optional[str] = Field(
+        None,
+        min_length=1,
+        max_length=10000,
+        description="Updated prompt text (creates new version if changed)"
+    )
+
+
+class PromptGroupResponse(PromptGroupBase):
+    """Schema for prompt group response"""
+    id: str
+    user_id: str = Field(alias="userId")
+    author_name: Optional[str] = Field(None, alias="authorName")
+    production_prompt_id: Optional[str] = Field(None, alias="productionPromptId")
+    is_shared: bool = Field(alias="isShared")
+    is_pinned: bool = Field(alias="isPinned")
+    created_at: int = Field(alias="createdAt")  # epoch milliseconds
+    updated_at: int = Field(alias="updatedAt")  # epoch milliseconds
+    
+    # Include production prompt if available
+    production_prompt: Optional[PromptResponse] = Field(None, alias="productionPrompt")
+    
+    class Config:
+        from_attributes = True
+        populate_by_name = True
+
+
+class PromptGroupListResponse(BaseModel):
+    """Schema for paginated prompt group list"""
+    groups: List[PromptGroupResponse]
+    total: int
+    skip: int
+    limit: int
+
+
+# AI-Assisted Prompt Builder Models
+
+class ChatMessage(BaseModel):
+    """Schema for a chat message"""
+    role: str = Field(
+        ..., 
+        pattern="^(user|assistant)$", 
+        description="Message role"
+    )
+    content: str = Field(..., min_length=1, description="Message content")
+
+
+class PromptBuilderChatRequest(BaseModel):
+    """Schema for prompt builder chat request"""
+    message: str = Field(
+        ...,
+        min_length=1,
+        max_length=200000,
+        description="User message (supports long conversation histories for template creation)"
+    )
+    conversation_history: List[ChatMessage] = Field(
+        default_factory=list, 
+        description="Previous messages"
+    )
+    current_template: Optional[Dict[str, Any]] = Field(
+        None, 
+        description="Current template state"
+    )
+
+
+class PromptBuilderChatResponse(BaseModel):
+    """Schema for prompt builder chat response"""
+    message: str = Field(..., description="Assistant's response message")
+    template_updates: Dict[str, Any] = Field(
+        default_factory=dict, 
+        description="Updates to template config"
+    )
+    confidence: float = Field(
+        0.0, 
+        ge=0.0, 
+        le=1.0, 
+        description="Confidence score"
+    )
+    ready_to_save: bool = Field(
+        False,
+        description="Whether template is ready to save"
+    )
+
+
+# Export/Import Models
+
+class PromptExportMetadata(BaseModel):
+    """Metadata for exported prompt"""
+    author_name: Optional[str] = Field(None, alias="authorName")
+    original_version: int = Field(alias="originalVersion")
+    original_created_at: int = Field(alias="originalCreatedAt")
+    
+    class Config:
+        populate_by_name = True
+
+
+class PromptExportData(BaseModel):
+    """Data structure for exported prompt"""
+    name: str
+    description: Optional[str] = None
+    category: Optional[str] = None
+    command: Optional[str] = None
+    prompt_text: str = Field(alias="promptText")
+    metadata: PromptExportMetadata
+    
+    class Config:
+        populate_by_name = True
+
+
+class PromptExportResponse(BaseModel):
+    """Schema for exported prompt file"""
+    version: str = "1.0"
+    exported_at: int = Field(alias="exportedAt")
+    prompt: PromptExportData
+    
+    class Config:
+        populate_by_name = True
+        by_alias = True
+
+
+class PromptImportOptions(BaseModel):
+    """Options for importing a prompt"""
+    preserve_command: bool = Field(
+        False,
+        alias="preserveCommand",
+        description="If true, attempt to keep original command (may be modified if conflict exists)"
+    )
+    preserve_category: bool = Field(
+        True,
+        alias="preserveCategory",
+        description="If true, keep the original category"
+    )
+    
+    class Config:
+        populate_by_name = True
+
+
+class PromptImportRequest(BaseModel):
+    """Schema for importing a prompt"""
+    prompt_data: Dict[str, Any] = Field(
+        ...,
+        description="The exported prompt JSON data"
+    )
+    options: Optional[PromptImportOptions] = Field(
+        default_factory=PromptImportOptions,
+        description="Import options"
+    )
+
+
+class PromptImportResponse(BaseModel):
+    """Schema for import response"""
+    success: bool
+    prompt_group_id: str = Field(alias="promptGroupId")
+    warnings: List[str] = Field(
+        default_factory=list,
+        description="Any warnings generated during import (e.g., command conflicts)"
+    )
+    
+    class Config:
+        populate_by_name = True
+        by_alias = True