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

solace_agent_mesh/gateway/http_sse/alembic/versions/20251126_add_background_task_fields.py

@@ -0,0 +1,47 @@
+"""Add background task execution fields
+
+Revision ID: 20251126_background_tasks
+Revises: 20251202_versioned_prompt_fields
+Create Date: 2025-11-26 17:30:00.000000
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '20251126_background_tasks'
+down_revision = '20251202_versioned_prompt_fields'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    """Add fields to support background task execution."""
+    # Add execution_mode column (foreground | background)
+    op.add_column('tasks', sa.Column('execution_mode', sa.String(20), nullable=True, server_default='foreground'))
+    
+    # Add last_activity_time for timeout detection
+    op.add_column('tasks', sa.Column('last_activity_time', sa.BigInteger, nullable=True))
+    
+    # Add background_execution_enabled flag
+    op.add_column('tasks', sa.Column('background_execution_enabled', sa.Boolean, nullable=True, server_default='false'))
+    
+    # Add max_execution_time_ms for timeout configuration
+    op.add_column('tasks', sa.Column('max_execution_time_ms', sa.BigInteger, nullable=True))
+    
+    # Create index on execution_mode for efficient queries
+    op.create_index('idx_tasks_execution_mode', 'tasks', ['execution_mode'])
+    
+    # Create index on last_activity_time for timeout monitoring
+    op.create_index('idx_tasks_last_activity', 'tasks', ['last_activity_time'])
+
+
+def downgrade():
+    """Remove background task execution fields."""
+    op.drop_index('idx_tasks_last_activity', table_name='tasks')
+    op.drop_index('idx_tasks_execution_mode', table_name='tasks')
+    op.drop_column('tasks', 'max_execution_time_ms')
+    op.drop_column('tasks', 'background_execution_enabled')
+    op.drop_column('tasks', 'last_activity_time')
+    op.drop_column('tasks', 'execution_mode')

solace_agent_mesh/gateway/http_sse/alembic/versions/20251202_add_versioned_fields_to_prompts.py

@@ -0,0 +1,52 @@
+"""Add versioned metadata fields to prompts table
+
+Revision ID: 20251202_versioned_prompt_fields
+Revises: 20251115_add_parent_task_id
+Create Date: 2025-12-02
+
+This migration adds name, description, category, and command fields to the prompts table
+to enable full versioning of all prompt metadata, not just the prompt_text content.
+"""
+
+from collections.abc import Sequence
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "20251202_versioned_prompt_fields"
+down_revision: str | Sequence[str] | None = "20251115_add_parent_task_id"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Add versioned metadata fields to prompts table."""
+    
+    # Add new columns to prompts table
+    with op.batch_alter_table('prompts', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('name', sa.String(length=255), nullable=True))
+        batch_op.add_column(sa.Column('description', sa.Text(), nullable=True))
+        batch_op.add_column(sa.Column('category', sa.String(length=100), nullable=True))
+        batch_op.add_column(sa.Column('command', sa.String(length=50), nullable=True))
+    
+    # Migrate existing data: copy metadata from prompt_groups to prompts
+    # This ensures existing prompt versions have the metadata from their group
+    connection = op.get_bind()
+    connection.execute(sa.text("""
+        UPDATE prompts 
+        SET name = pg.name,
+            description = pg.description,
+            category = pg.category,
+            command = pg.command
+        FROM prompt_groups pg
+        WHERE prompts.group_id = pg.id
+    """))
+
+
+def downgrade() -> None:
+    """Remove versioned metadata fields from prompts table."""
+    
+    with op.batch_alter_table('prompts', schema=None) as batch_op:
+        batch_op.drop_column('command')
+        batch_op.drop_column('category')
+        batch_op.drop_column('description')
+        batch_op.drop_column('name')

solace_agent_mesh/gateway/http_sse/alembic.ini

@@ -107,39 +107,3 @@ path_separator = os
 # ruff.type = exec
 # ruff.executable = ruff
 # ruff.options = check --fix REVISION_SCRIPT_FILENAME
-
-# Logging configuration.  This is also consumed by the user-maintained
-# env.py script only.
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = WARNING
-handlers = console
-qualname =
-
-[logger_sqlalchemy]
-level = WARNING
-handlers =
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = INFO
-handlers =
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-[formatter_generic]
-format = %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %H:%M:%S

solace_agent_mesh/gateway/http_sse/app.py

@@ -166,6 +166,20 @@ class WebUIBackendApp(BaseGatewayApp):
             "default": "",
             "description": "The passphrase for the SSL private key.",
         },
+        {
+            "name": "frontend_server_url",
+            "required": False,
+            "type": "string",
+            "default": "",
+            "description": (
+                "The WebUI Gateway's public URL for frontend API requests. "
+                "If empty (default), the frontend uses relative URLs for same-origin requests. "
+                "Only set this if the frontend is served from a different origin than the WebUI Gateway. "
+                "Examples: "
+                "  - Same-origin (default): '' (empty, uses relative URLs like /api/v1/...) "
+                "  - Cross-origin: https://webui-gateway.example.com"
+            ),
+        },
         {
             "name": "session_service",
             "required": False,
@@ -193,16 +207,19 @@ class WebUIBackendApp(BaseGatewayApp):
             "required": False,
             "type": "dict",
             "default": {},
-            "description": "Configuration for the Platform Service (enterprise features: agents, connectors, deployments).",
+            "description": "Configuration for connecting to the Platform Service (runs separately on port 8001).",
             "dict_schema": {
-                "database_url": {
+                "url": {
                     "type": "string",
                     "required": False,
-                    "default": None,
+                    "default": "",
                     "description": (
-                        "Database URL for platform data (agents, connectors, deployments). "
-                        "REQUIRED for platform features to be available. "
-                        "Example: postgresql://user:pass@host:5432/platform_db"
+                        "Platform Service URL for frontend API routing to enterprise endpoints. "
+                        "Frontend will call this URL for /api/v1/platform/* requests. "
+                        "Examples: "
+                        "  - Docker: http://platform-service:8001 "
+                        "  - K8s: http://platform-service:8001 "
+                        "  - Local: http://localhost:8001"
                     ),
                 },
             },

solace_agent_mesh/gateway/http_sse/component.py

@@ -124,6 +124,13 @@ class WebUIBackendComponent(BaseGatewayComponent):
             self.ssl_keyfile_password = self.get_config("ssl_keyfile_password", "")
             self.model_config = self.get_config("model", None)
 
+            # OAuth2 configuration (enterprise feature - defaults to community mode)
+            self.external_auth_service_url = self.get_config("external_auth_service_url", "")
+            self.external_auth_provider = self.get_config("external_auth_provider", "generic")
+
+            # frontend_server_url is optional - empty string means frontend uses relative URLs
+            self.frontend_server_url = self.get_config("frontend_server_url", "")
+
             log.info(
                 "%s WebUI-specific configuration retrieved (Host: %s, Port: %d).",
                 self.log_identifier,
@@ -134,16 +141,15 @@ class WebUIBackendComponent(BaseGatewayComponent):
             log.error("%s Failed to retrieve configuration: %s", self.log_identifier, e)
             raise ValueError(f"Configuration retrieval error: {e}") from e
 
-        sse_max_queue_size = self.get_config("sse_max_queue_size", 200)
+        self.sse_max_queue_size = self.get_config("sse_max_queue_size", 200)
         sse_buffer_max_age_seconds = self.get_config("sse_buffer_max_age_seconds", 600)
 
         self.sse_event_buffer = SSEEventBuffer(
-            max_queue_size=sse_max_queue_size,
+            max_queue_size=self.sse_max_queue_size,
             max_age_seconds=sse_buffer_max_age_seconds,
         )
-        self.sse_manager = SSEManager(
-            max_queue_size=sse_max_queue_size, event_buffer=self.sse_event_buffer
-        )
+        # SSE manager will be initialized after database setup
+        self.sse_manager = None
 
         self._sse_cleanup_timer_id = f"sse_cleanup_{self.gateway_id}"
         cleanup_interval_sec = self.get_config(
@@ -212,7 +218,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 )
 
         platform_config = self.get_config("platform_service", {})
-        self.platform_database_url = platform_config.get("database_url")
+        self.platform_service_url = platform_config.get("url", "")
         component_config = self.get_config("component_config", {})
         app_config = component_config.get("app_config", {})
 
@@ -240,6 +246,10 @@ class WebUIBackendComponent(BaseGatewayComponent):
         self._task_logger_broker_input: BrokerInput | None = None
         self._task_logger_processor_task: asyncio.Task | None = None
         self.task_logger_service: TaskLoggerService | None = None
+        
+        # Background task monitor
+        self.background_task_monitor = None
+        self._background_task_monitor_timer_id = None
 
         # Initialize SAM Events service for system events
         from ...common.sam_events import SamEventService
@@ -298,8 +308,27 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 "%s Data retention is disabled via configuration.", self.log_identifier
             )
 
+        if self.database_url:
+            log.info("%s Running database migrations...", self.log_identifier)
+            self._run_database_migrations()
+            log.info("%s Database migrations completed", self.log_identifier)
+
         log.info("%s Web UI Backend Component initialized.", self.log_identifier)
 
+    def _run_database_migrations(self):
+        """Run database migrations synchronously during __init__."""
+        try:
+            from ...gateway.http_sse.main import _setup_database
+            _setup_database(self.database_url)
+        except Exception as e:
+            log.error(
+                "%s Failed to run database migrations: %s",
+                self.log_identifier,
+                e,
+                exc_info=True
+            )
+            raise RuntimeError(f"Database migration failed during component initialization: {e}") from e
+
     def process_event(self, event: Event):
         if event.event_type == EventType.TIMER:
             timer_id = event.data.get("timer_id")
@@ -333,6 +362,27 @@ class WebUIBackendComponent(BaseGatewayComponent):
                         self.log_identifier,
                     )
                 return
+            
+            if timer_id == self._background_task_monitor_timer_id:
+                log.debug("%s Background task monitor timer triggered.", self.log_identifier)
+                if self.background_task_monitor:
+                    loop = self.get_async_loop()
+                    if loop and loop.is_running():
+                        asyncio.run_coroutine_threadsafe(
+                            self.background_task_monitor.check_timeouts(),
+                            loop
+                        )
+                    else:
+                        log.warning(
+                            "%s Async loop not available for background task monitor.",
+                            self.log_identifier
+                        )
+                else:
+                    log.warning(
+                        "%s Background task monitor timer fired but service is not initialized.",
+                        self.log_identifier,
+                    )
+                return
 
         super().process_event(event)
 
@@ -388,7 +438,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             broker_input_cfg = {
                 "component_module": "broker_input",
                 "component_name": f"{self.gateway_id}_viz_broker_input",
-                "broker_queue_name": f"{self.namespace.strip('/')}/q/gdk/viz/{self.gateway_id}/{uuid.uuid4().hex}",
+                "broker_queue_name": f"{self.namespace.strip('/')}/q/gdk/viz/{self.gateway_id}",
                 "create_queue_on_start": True,
                 "component_config": {
                     "broker_url": main_broker_config.get("broker_url"),
@@ -522,7 +572,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             broker_input_cfg = {
                 "component_module": "broker_input",
                 "component_name": f"{self.gateway_id}_task_log_broker_input",
-                "broker_queue_name": f"{self.namespace.strip('/')}/q/gdk/task_log/{self.gateway_id}/{uuid.uuid4().hex}",
+                "broker_queue_name": f"{self.namespace.strip('/')}/q/gdk/task_log/{self.gateway_id}",
                 "create_queue_on_start": True,
                 "component_config": {
                     "broker_url": main_broker_config.get("broker_url"),
@@ -812,11 +862,34 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                     event_details["direction"],
                                 )
                             except asyncio.QueueFull:
-                                log.warning(
-                                    "%s SSE queue full for stream %s. Visualization message dropped.",
-                                    log_id_prefix,
-                                    stream_id,
-                                )
+                                # Check if this is a background task
+                                is_background = False
+                                if task_id_for_context and self.database_url:
+                                    try:
+                                        from .repository.task_repository import TaskRepository
+                                        db = dependencies.SessionLocal()
+                                        try:
+                                            repo = TaskRepository()
+                                            task = repo.find_by_id(db, task_id_for_context)
+                                            is_background = task and task.background_execution_enabled
+                                        finally:
+                                            db.close()
+                                    except Exception:
+                                        pass
+                                
+                                if is_background:
+                                    log.debug(
+                                        "%s SSE queue full for stream %s. Dropping visualization message for background task %s.",
+                                        log_id_prefix,
+                                        stream_id,
+                                        task_id_for_context,
+                                    )
+                                else:
+                                    log.warning(
+                                        "%s SSE queue full for stream %s. Visualization message dropped.",
+                                        log_id_prefix,
+                                        stream_id,
+                                    )
                             except Exception as send_err:
                                 log.error(
                                     "%s Error sending formatted message to SSE queue for stream %s: %s",
@@ -1229,11 +1302,22 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
             self.fastapi_app = fastapi_app_instance
 
-            setup_dependencies(self, self.database_url, self.platform_database_url)
+            setup_dependencies(self)
 
             # Instantiate services that depend on the database session factory.
             # This must be done *after* setup_dependencies has run.
             session_factory = dependencies.SessionLocal if self.database_url else None
+            
+            # Initialize SSE manager with session factory for background task detection
+            self.sse_manager = SSEManager(
+                max_queue_size=self.sse_max_queue_size,
+                event_buffer=self.sse_event_buffer,
+                session_factory=session_factory
+            )
+            log.debug(
+                "%s SSE manager initialized with database session factory.",
+                self.log_identifier,
+            )
             task_logging_config = self.get_config("task_logging", {})
             self.task_logger_service = TaskLoggerService(
                 session_factory=session_factory, config=task_logging_config
@@ -1242,6 +1326,55 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 "%s Services dependent on database session factory have been initialized.",
                 self.log_identifier,
             )
+            
+            # Initialize background task monitor if task logging is enabled
+            if self.database_url and task_logging_config.get("enabled", False):
+                from .services.background_task_monitor import BackgroundTaskMonitor
+                from .services.task_service import TaskService
+                
+                # Create task service for cancellation operations
+                task_service = TaskService(
+                    core_a2a_service=self.core_a2a_service,
+                    publish_func=self.publish_a2a,
+                    namespace=self.namespace,
+                    gateway_id=self.gateway_id,
+                    sse_manager=self.sse_manager,
+                    task_context_map=self.task_context_manager._contexts,
+                    task_context_lock=self.task_context_manager._lock,
+                    app_name=self.name,
+                )
+                
+                # Get timeout configuration
+                background_config = self.get_config("background_tasks", {})
+                default_timeout_ms = background_config.get("default_timeout_ms", 3600000)  # 1 hour
+                
+                self.background_task_monitor = BackgroundTaskMonitor(
+                    session_factory=session_factory,
+                    task_service=task_service,
+                    default_timeout_ms=default_timeout_ms,
+                )
+                
+                # Create timer for periodic timeout checks
+                monitor_interval_ms = background_config.get("monitor_interval_ms", 300000)  # 5 minutes
+                self._background_task_monitor_timer_id = f"background_task_monitor_{self.gateway_id}"
+                
+                self.add_timer(
+                    delay_ms=monitor_interval_ms,
+                    timer_id=self._background_task_monitor_timer_id,
+                    interval_ms=monitor_interval_ms,
+                )
+                
+                log.info(
+                    "%s Background task monitor initialized with %dms check interval and %dms default timeout",
+                    self.log_identifier,
+                    monitor_interval_ms,
+                    default_timeout_ms
+                )
+            else:
+                log.info(
+                    "%s Background task monitor not initialized (task logging disabled or no database)",
+                    self.log_identifier
+                )
 
             port = (
                 self.fastapi_https_port
@@ -1258,6 +1391,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 ssl_keyfile=self.ssl_keyfile,
                 ssl_certfile=self.ssl_certfile,
                 ssl_keyfile_password=self.ssl_keyfile_password,
+                log_config=None
             )
             self.uvicorn_server = uvicorn.Server(config)
 
@@ -1345,39 +1479,6 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     )
                     self.stop_signal.set()
 
-                try:
-                    from solace_agent_mesh_enterprise.init_enterprise import (
-                        start_enterprise_background_tasks,
-                    )
-
-                    log.info(
-                        "%s Starting enterprise background tasks...",
-                        self.log_identifier,
-                    )
-                    await start_enterprise_background_tasks(self)
-                    log.info(
-                        "%s Enterprise background tasks started successfully",
-                        self.log_identifier,
-                    )
-                except ImportError:
-                    log.debug(
-                        "%s Enterprise package not available - skipping background tasks",
-                        self.log_identifier,
-                    )
-                except RuntimeError as enterprise_err:
-                    log.warning(
-                        "%s Enterprise background tasks disabled: %s - Community features will continue normally",
-                        self.log_identifier,
-                        enterprise_err,
-                    )
-                except Exception as enterprise_err:
-                    log.error(
-                        "%s Failed to start enterprise background tasks: %s - Community features will continue normally",
-                        self.log_identifier,
-                        enterprise_err,
-                        exc_info=True,
-                    )
-
             @self.fastapi_app.on_event("shutdown")
             async def shutdown_event():
                 log.info(
@@ -1385,32 +1486,6 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     self.log_identifier,
                 )
 
-                try:
-                    from solace_agent_mesh_enterprise.init_enterprise import (
-                        stop_enterprise_background_tasks,
-                    )
-
-                    log.info(
-                        "%s Stopping enterprise background tasks...",
-                        self.log_identifier,
-                    )
-                    await stop_enterprise_background_tasks()
-                    log.info(
-                        "%s Enterprise background tasks stopped", self.log_identifier
-                    )
-                except ImportError:
-                    log.debug(
-                        "%s Enterprise package not available - no background tasks to stop",
-                        self.log_identifier,
-                    )
-                except Exception as enterprise_err:
-                    log.error(
-                        "%s Failed to stop enterprise background tasks: %s",
-                        self.log_identifier,
-                        enterprise_err,
-                        exc_info=True,
-                    )
-
             self.fastapi_thread = threading.Thread(
                 target=self.uvicorn_server.run, daemon=True, name="FastAPI_Thread"
             )
@@ -1479,11 +1554,20 @@ class WebUIBackendComponent(BaseGatewayComponent):
         if self._data_retention_timer_id:
             self.cancel_timer(self._data_retention_timer_id)
             log.info("%s Cancelled data retention cleanup timer.", self.log_identifier)
+        
+        if self._background_task_monitor_timer_id:
+            self.cancel_timer(self._background_task_monitor_timer_id)
+            log.info("%s Cancelled background task monitor timer.", self.log_identifier)
 
         # Clean up data retention service
         if self.data_retention_service:
             self.data_retention_service = None
             log.info("%s Data retention service cleaned up.", self.log_identifier)
+        
+        # Clean up background task monitor
+        if self.background_task_monitor:
+            self.background_task_monitor = None
+            log.info("%s Background task monitor cleaned up.", self.log_identifier)
 
         self.cancel_timer(self.health_check_timer_id)
         log.info("%s Cleaning up visualization resources...", self.log_identifier)
@@ -2187,6 +2271,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 log_id_prefix,
                 sse_task_id,
             )
+            
 
     async def _send_error_to_external(
         self, external_request_context: dict[str, Any], error_data: JSONRPCError