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

solace_agent_mesh/gateway/http_sse/routers/config.py

@@ -1,24 +1,32 @@
 """
 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 ..routers.dto.requests.project_requests import CreateProjectRequest, UpdateProjectRequest
-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()
 
 
-def _get_validation_limits() -> Dict[str, Any]:
+# 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.
@@ -26,13 +34,69 @@ def _get_validation_limits() -> Dict[str, Any]:
     # 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],
@@ -96,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)
@@ -119,24 +257,111 @@ async def get_app_config(
             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(),
+            "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.debug("%sReturning frontend configuration.", log_prefix)
         return config_data

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

solace_agent_mesh/gateway/http_sse/routers/dto/requests/session_requests.py

@@ -5,7 +5,7 @@ Session-related request DTOs.
 from typing import Optional
 from pydantic import BaseModel, Field
 
-from ....shared.types import SessionId, UserId
+from solace_agent_mesh.shared.utils.types import SessionId, UserId
 
 
 class GetSessionRequest(BaseModel):

solace_agent_mesh/gateway/http_sse/routers/dto/responses/base_responses.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict
 
-from ....shared import epoch_ms_to_iso8601
+from solace_agent_mesh.shared.utils.timestamp_utils import epoch_ms_to_iso8601
 
 
 class BaseTimestampResponse(BaseModel):

solace_agent_mesh/gateway/http_sse/routers/dto/responses/project_responses.py

@@ -17,6 +17,7 @@ class ProjectResponse(BaseTimestampResponse):
     description: Optional[str] = None
     system_prompt: Optional[str] = Field(default=None, alias="systemPrompt")
     default_agent_id: Optional[str] = Field(default=None, alias="defaultAgentId")
+    artifact_count: Optional[int] = Field(default=None, alias="artifactCount")
     created_at: int = Field(alias="createdAt")
     updated_at: Optional[int] = Field(default=None, alias="updatedAt")
 

solace_agent_mesh/gateway/http_sse/routers/dto/responses/session_responses.py

@@ -4,8 +4,8 @@ Session-related response DTOs.
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from ....shared.pagination import PaginationMeta
-from ....shared.types import SessionId, UserId
+from solace_agent_mesh.shared.api.pagination import PaginationMeta
+from solace_agent_mesh.shared.utils.types import SessionId, UserId
 from .base_responses import BaseTimestampResponse
 
 
@@ -18,6 +18,7 @@ class SessionResponse(BaseTimestampResponse):
     agent_id: str | None = Field(default=None, alias="agentId")
     project_id: str | None = Field(default=None, alias="projectId")
     project_name: str | None = Field(default=None, alias="projectName")
+    has_running_background_task: bool = Field(default=False, alias="hasRunningBackgroundTask")
     created_time: int = Field(alias="createdTime")
     updated_time: int | None = Field(default=None, alias="updatedTime")