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

solace_agent_mesh/gateway/generic/component.py

@@ -27,6 +27,13 @@ from ...agent.utils.artifact_helpers import (
     load_artifact_content_or_metadata,
 )
 from ...common.a2a.types import ArtifactInfo
+from ...common.utils.mime_helpers import is_text_based_mime_type
+from ...common.utils.embeds import (
+    LATE_EMBED_TYPES,
+    evaluate_embed,
+    resolve_embeds_recursively_in_string,
+)
+from ...common.utils.embeds.types import ResolutionMode
 from ..adapter.base import GatewayAdapter
 from ..adapter.types import (
     GatewayContext,
@@ -40,6 +47,15 @@ from ..adapter.types import (
 )
 from ..base.component import BaseGatewayComponent
 
+# Try to import enterprise auth handler
+try:
+    from solace_agent_mesh_enterprise.gateway.auth import SAMOAuth2Handler
+    ENTERPRISE_AUTH_AVAILABLE = True
+except ImportError:
+    ENTERPRISE_AUTH_AVAILABLE = False
+    SAMOAuth2Handler = None
+
+
 log = logging.getLogger(__name__)
 
 info = {
@@ -90,7 +106,7 @@ class GenericGatewayComponent(BaseGatewayComponent, GatewayContext):
             resolve_artifact_uris_in_gateway=resolve_uris,
             supports_inline_artifact_resolution=True,
             filter_tool_data_parts=False,
-            **kwargs
+            **kwargs,
         )
         log.info("%s Initializing Generic Gateway Component...", self.log_identifier)
 
@@ -125,48 +141,181 @@ class GenericGatewayComponent(BaseGatewayComponent, GatewayContext):
         self.artifact_service = self.shared_artifact_service
         # `gateway_id`, `namespace`, `config` are available from base classes.
 
-    # --- GatewayContext Implementation ---
+        # --- Setup Authentication ---
+        self._setup_auth()
 
-    async def handle_external_input(
-        self, external_input: Any, endpoint_context: Optional[Dict[str, Any]] = None
-    ) -> str:
+        # --- Register Agent Registry Callbacks ---
+        # Wire up callbacks so the adapter is notified of agent changes
+        self.agent_registry.set_on_agent_added_callback(self._on_agent_added)
+        self.agent_registry.set_on_agent_removed_callback(self._on_agent_removed)
+        log.info(
+            "%s Agent registry callbacks registered for dynamic adapter updates.",
+            self.log_identifier,
+        )
+
+    def _setup_auth(self) -> None:
         """
-        Processes an external input event through the full gateway flow.
-        Orchestrates auth, task preparation, and A2A submission.
+        Setup authentication handler if enabled in config.
+
+        Uses enterprise SAMOAuth2Handler if available and auth is enabled.
+        Falls back gracefully if enterprise module is not installed.
+
+        Note: This method is called twice:
+        1. During BaseGatewayComponent.__init__() (adapter_config not yet available)
+        2. After adapter_config is set in GenericGatewayComponent.__init__()
         """
-        log_id_prefix = f"{self.log_identifier}[HandleInput]"
+        # Early exit if adapter_config not yet set
+        if not hasattr(self, 'adapter_config'):
+            log.debug("%s _setup_auth() called before adapter_config set, skipping", self.log_identifier)
+            return
+
+        log.debug("%s adapter_config type: %s", self.log_identifier, type(self.adapter_config))
+
+        # Check enable_auth from adapter_config (not app_config)
+        # Handle both Pydantic models (use getattr) and plain dicts (use .get())
+        if isinstance(self.adapter_config, dict):
+            enable_auth = self.adapter_config.get('enable_auth', False)
+            log.debug("%s adapter_config is dict, keys: %s", self.log_identifier, list(self.adapter_config.keys()))
+        else:
+            # Pydantic model or other object
+            enable_auth = getattr(self.adapter_config, 'enable_auth', False)
+            log.debug("%s adapter_config is Pydantic model, enable_auth=%s", self.log_identifier, enable_auth)
+
+        log.info("%s Authentication check: enable_auth=%s (from adapter_config)", self.log_identifier, enable_auth)
+
+        if not enable_auth:
+            log.debug("%s Authentication disabled in config", self.log_identifier)
+            return
+
+        if not ENTERPRISE_AUTH_AVAILABLE:
+            log.warning(
+                "%s Authentication enabled but enterprise module not available. "
+                "Install solace-agent-mesh-enterprise to enable OAuth2 authentication.",
+                self.log_identifier
+            )
+            return
+
+        try:
+            # Build config dict for SAMOAuth2Handler from adapter_config
+            # Handler expects: oauth_proxy_url, external_auth_service_url, external_auth_provider, callback_url
+            auth_config = {}
+
+            # Try to get config from adapter_config (Pydantic model or dict)
+            if hasattr(self.adapter_config, '__dict__'):
+                # Pydantic model
+                auth_config = self.adapter_config.__dict__.copy()
+            elif isinstance(self.adapter_config, dict):
+                # Plain dict
+                auth_config = self.adapter_config.copy()
+
+            # Ensure callback_url is set (construct from host/port if not provided)
+            if 'callback_url' not in auth_config and 'callback_uri' not in auth_config:
+                # Try to construct from host and port
+                host = auth_config.get('host', 'localhost')
+                port = auth_config.get('port', 8080)
+                auth_config['callback_url'] = f"http://{host}:{port}/oauth/callback"
+                log.debug("%s Constructed callback_url: %s", self.log_identifier, auth_config['callback_url'])
+
+            # Initialize enterprise OAuth2 handler
+            self.auth_handler = SAMOAuth2Handler(auth_config)
+            log.info("%s OAuth2 authentication enabled via enterprise module", self.log_identifier)
+        except Exception as e:
+            log.error("%s Failed to initialize OAuth2 authentication: %s", self.log_identifier, e, exc_info=True)
+            self.auth_handler = None
+
+    def _on_agent_added(self, agent_card: Any) -> None:
+        """Called when a new agent is added to the registry."""
+        if self.adapter:
+            log.info(
+                "%s Registering new agent: %s",
+                self.log_identifier,
+                agent_card.name,
+            )
+            # Schedule the async call in the component's event loop
+            asyncio.run_coroutine_threadsafe(
+                self.adapter.handle_agent_registered(agent_card), self.get_async_loop()
+            )
+
+    def _on_agent_removed(self, agent_name: str) -> None:
+        """Called when an agent is removed from the registry."""
+        log.info(
+            "%s Deregistering agent: %s",
+            self.log_identifier,
+            agent_name,
+        )
+
+        if self.adapter:
+            # Schedule the async call in the component's event loop
+            asyncio.run_coroutine_threadsafe(
+                self.adapter.handle_agent_deregistered(agent_name), self.get_async_loop()
+            )
+
+    async def get_user_identity(
+            self, external_input: Any, endpoint_context: Optional[Dict[str, Any]] = None
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Extracts the user identity from the external input via the adapter.
+
+        Returns:
+            A dictionary representing the user identity, or None if not available.
+        """
+        log_id_prefix = f"{self.log_identifier}[GetUserIdentity]"
         user_identity = None
+        # 1. Authentication & Enrichment
+        # Try enterprise authentication first, fallback to adapter-based auth
         try:
-            # 1. Authentication & Enrichment
+            from solace_agent_mesh_enterprise.gateway.auth import authenticate_request
+
+            auth_claims = await authenticate_request(
+                adapter=self.adapter,
+                external_input=external_input,
+                endpoint_context=endpoint_context,
+            )
+            log.debug("%s Using enterprise authentication", log_id_prefix)
+        except ImportError:
+            # Enterprise package not available, use adapter-based auth
+            log.debug("%s Enterprise package not available, using adapter auth", log_id_prefix)
             auth_claims = await self.adapter.extract_auth_claims(
                 external_input, endpoint_context
             )
 
-            # The final user_identity is a dictionary, not the Pydantic model.
-            # It's built from claims and potentially enriched by an identity service.
-            if auth_claims:
-                if self.identity_service:
-                    # Pass the rich claims object to the identity service
-                    enriched_profile = await self.identity_service.get_user_profile(
-                        auth_claims
-                    )
-                    if enriched_profile:
-                        # Merge claims and profile, with profile taking precedence
-                        user_identity = {
-                            **auth_claims.model_dump(),
-                            **enriched_profile,
-                        }
-                    else:
-                        user_identity = auth_claims.model_dump()
+        # The final user_identity is a dictionary, not the Pydantic model.
+        # It's built from claims and potentially enriched by an identity service.
+        if auth_claims:
+            if self.identity_service:
+                # Pass the rich claims object to the identity service
+                enriched_profile = await self.identity_service.get_user_profile(
+                    auth_claims
+                )
+                if enriched_profile:
+                    # Merge claims and profile, with profile taking precedence
+                    user_identity = {
+                        **auth_claims.model_dump(),
+                        **enriched_profile,
+                    }
                 else:
-                    # No identity service, just use the claims from the adapter
                     user_identity = auth_claims.model_dump()
             else:
-                # Fallback to default identity if no claims are extracted
-                default_identity = self.get_config("default_user_identity")
-                if default_identity:
-                    user_identity = {"id": default_identity, "name": default_identity}
+                # No identity service, just use the claims from the adapter
+                user_identity = auth_claims.model_dump()
+        else:
+            # Fallback to default identity if no claims are extracted
+            default_identity = self.get_config("default_user_identity")
+            if default_identity:
+                user_identity = {"id": default_identity, "name": default_identity}
+        return user_identity
 
+    async def handle_external_input(
+        self, external_input: Any, endpoint_context: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Processes an external input event through the full gateway flow.
+        Orchestrates auth, task preparation, and A2A submission.
+        """
+        log_id_prefix = f"{self.log_identifier}[HandleInput]"
+        user_identity = None
+        try:
+            user_identity = await self.get_user_identity(external_input, endpoint_context)
             if not user_identity or not user_identity.get("id"):
                 raise PermissionError(
                     "Authentication failed: No identity could be determined."
@@ -175,6 +324,8 @@ class GenericGatewayComponent(BaseGatewayComponent, GatewayContext):
             log.info(
                 "%s Authenticated user: %s", log_id_prefix, user_identity.get("id")
             )
+            # Add user_id to external_input so adapter can use it for permission checks.
+            external_input["user_id"] = user_identity.get("id")
 
             # 2. Task Preparation
             sam_task = await self.adapter.prepare_task(external_input, endpoint_context)
@@ -194,6 +345,10 @@ class GenericGatewayComponent(BaseGatewayComponent, GatewayContext):
                 **sam_task.platform_context,
             }
 
+            # Pass session_behavior if provided by adapter
+            if sam_task.session_behavior:
+                external_request_context["session_behavior"] = sam_task.session_behavior
+
             task_id = await self.submit_a2a_task(
                 target_agent_name=sam_task.target_agent,
                 a2a_parts=a2a_parts,
@@ -217,6 +372,7 @@ class GenericGatewayComponent(BaseGatewayComponent, GatewayContext):
                     # Create a dummy context to report the error
                     error_context = ResponseContext(
                         task_id="pre-task-error",
+                        session_id=None,
                         conversation_id=None,
                         user_id=user_identity.get("id"),
                         platform_context={},
@@ -294,7 +450,79 @@ class GenericGatewayComponent(BaseGatewayComponent, GatewayContext):
             )
             if artifact_data.get("status") == "success":
                 content_bytes = artifact_data.get("raw_bytes")
+                mime_type = artifact_data.get("mime_type")
+
                 if content_bytes:
+                    # For text-based artifacts, resolve templates and late embeds
+                    if mime_type and is_text_based_mime_type(mime_type):
+                        try:
+
+                            content_str = content_bytes.decode("utf-8")
+
+                            # Build context for resolution
+                            context_for_resolver = {
+                                "artifact_service": self.artifact_service,
+                                "session_context": {
+                                    "app_name": self.gateway_id,
+                                    "user_id": context.user_id,
+                                    "session_id": context.session_id,
+                                },
+                            }
+
+                            config_for_resolver = {
+                                "gateway_max_artifact_resolve_size_bytes": (
+                                    self.gateway_max_artifact_resolve_size_bytes
+                                    if hasattr(
+                                        self, "gateway_max_artifact_resolve_size_bytes"
+                                    )
+                                    else -1
+                                ),
+                                "gateway_recursive_embed_depth": (
+                                    self.gateway_recursive_embed_depth
+                                    if hasattr(self, "gateway_recursive_embed_depth")
+                                    else 12
+                                ),
+                            }
+
+                            log.debug(
+                                "%s Text-based artifact. Resolving late embeds and templates.",
+                                log_id_prefix,
+                            )
+
+                            # Resolve late embeds
+                            resolved_content_str = await resolve_embeds_recursively_in_string(
+                                text=content_str,
+                                context=context_for_resolver,
+                                resolver_func=evaluate_embed,
+                                types_to_resolve=LATE_EMBED_TYPES,
+                                resolution_mode=ResolutionMode.RECURSIVE_ARTIFACT_CONTENT,
+                                log_identifier=f"{log_id_prefix}[RecursiveResolve]",
+                                config=config_for_resolver,
+                                max_depth=config_for_resolver[
+                                    "gateway_recursive_embed_depth"
+                                ],
+                                max_total_size=config_for_resolver[
+                                    "gateway_max_artifact_resolve_size_bytes"
+                                ],
+                            )
+
+                            # Template blocks are automatically resolved by resolve_embeds_recursively_in_string
+                            # when resolving late embeds. No need to call template resolution separately.
+
+                            content_bytes = resolved_content_str.encode("utf-8")
+                            log.info(
+                                "%s Resolved embeds (including templates). Final size: %d bytes.",
+                                log_id_prefix,
+                                len(content_bytes),
+                            )
+                        except Exception as resolve_err:
+                            log.warning(
+                                "%s Failed to resolve embeds/templates: %s. Returning original content.",
+                                log_id_prefix,
+                                resolve_err,
+                            )
+                            # Fall through to return original content_bytes
+
                     log.info(
                         "%s Successfully loaded %d bytes for artifact '%s'.",
                         log_id_prefix,
@@ -357,6 +585,22 @@ class GenericGatewayComponent(BaseGatewayComponent, GatewayContext):
             )
             return []
 
+    def list_agents(self) -> List[Any]:
+        """Lists all agents currently registered in the agent registry."""
+        log_id_prefix = f"{self.log_identifier}[ListAgents]"
+        try:
+            agent_names = self.agent_registry.get_agent_names()
+            agents = []
+            for agent_name in agent_names:
+                agent_card = self.agent_registry.get_agent(agent_name)
+                if agent_card:
+                    agents.append(agent_card)
+            log.info("%s Found %d registered agents.", log_id_prefix, len(agents))
+            return agents
+        except Exception as e:
+            log.exception("%s Failed to list agents: %s", log_id_prefix, e)
+            return []
+
     async def submit_feedback(self, feedback: "SamFeedback") -> None:
         """Handles feedback submission from an adapter."""
         log_id_prefix = f"{self.log_identifier}[SubmitFeedback]"

solace_agent_mesh/gateway/http_sse/alembic/env.py

@@ -1,5 +1,3 @@
-from logging.config import fileConfig
-
 from alembic import context
 from sqlalchemy import engine_from_config, pool
 
@@ -7,11 +5,6 @@ from sqlalchemy import engine_from_config, pool
 # access to the values within the .ini file in use.
 config = context.config
 
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
 # add your model's MetaData object here
 # for 'autogenerate' support
 from solace_agent_mesh.gateway.http_sse.repository.models.base import Base

solace_agent_mesh/gateway/http_sse/alembic/versions/20251023_add_soft_delete_and_search.py

@@ -65,56 +65,15 @@ def upgrade() -> None:
             op.create_index('ix_projects_user_deleted', 'projects', ['user_id', 'deleted_at'])
         except Exception:
             pass
-    
-    # Enable pg_trgm extension for fuzzy text search (PostgreSQL only)
-    try:
-        op.execute('CREATE EXTENSION IF NOT EXISTS pg_trgm')
-    except Exception:
-        # Not PostgreSQL or extension already exists
-        pass
-    
-    # Create GIN indexes for text search on sessions
-    if 'sessions' in inspector.get_table_names():
-        try:
-            # Index on session name for fuzzy search
-            op.execute(
-                'CREATE INDEX IF NOT EXISTS ix_sessions_name_trgm ON sessions '
-                'USING gin (name gin_trgm_ops)'
-            )
-        except Exception:
-            pass
-    
-    # Create GIN indexes for text search on chat_tasks
-    if 'chat_tasks' in inspector.get_table_names():
-        try:
-            # Index on user_message for content search
-            op.execute(
-                'CREATE INDEX IF NOT EXISTS ix_chat_tasks_user_message_trgm ON chat_tasks '
-                'USING gin (user_message gin_trgm_ops)'
-            )
-        except Exception:
-            pass
 
 
 def downgrade() -> None:
     """Remove soft delete columns and search indexes."""
     bind = op.get_bind()
     inspector = inspect(bind)
-    
-    # Drop search indexes from chat_tasks
-    if 'chat_tasks' in inspector.get_table_names():
-        try:
-            op.execute('DROP INDEX IF EXISTS ix_chat_tasks_user_message_trgm')
-        except Exception:
-            pass
-    
-    # Drop search indexes from sessions
+
+    # Drop soft delete indexes from sessions
     if 'sessions' in inspector.get_table_names():
-        try:
-            op.execute('DROP INDEX IF EXISTS ix_sessions_name_trgm')
-        except Exception:
-            pass
-        
         try:
             op.drop_index('ix_sessions_user_deleted', table_name='sessions')
         except Exception:

solace_agent_mesh/gateway/http_sse/alembic/versions/20251024_add_default_agent_to_projects.py

@@ -1,7 +1,7 @@
 """add default agent to projects
 
 Revision ID: default_agent_001
-Revises: fts_indexes_001
+Revises: soft_del_search_001
 Create Date: 2025-01-24 01:13:00.000000
 
 """
@@ -11,7 +11,7 @@ import sqlalchemy as sa
 
 # revision identifiers, used by Alembic.
 revision = 'default_agent_001'
-down_revision = 'fts_indexes_001'
+down_revision = 'soft_del_search_001'
 branch_labels = None
 depends_on = None
 

solace_agent_mesh/gateway/http_sse/alembic/versions/20251108_create_prompt_tables_with_sharing.py

@@ -0,0 +1,154 @@
+"""Create prompt tables with role-based sharing support
+
+Revision ID: 20251108_prompt_tables_complete
+Revises: 20251103_merge_heads
+Create Date: 2025-11-08
+
+This is a squashed migration that combines:
+- Initial prompt tables creation
+- Prompt pinning feature
+- Role-based sharing via prompt_group_users table
+"""
+
+from collections.abc import Sequence
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "20251108_prompt_tables_complete"
+down_revision: str | Sequence[str] | None = "default_agent_001"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Create complete prompt schema with sharing support."""
+    
+    # 1. Create prompts table (individual prompt versions)
+    op.create_table(
+        'prompts',
+        sa.Column('id', sa.String(), nullable=False),
+        sa.Column('prompt_text', sa.Text(), nullable=False),
+        sa.Column('group_id', sa.String(), nullable=False),
+        sa.Column('user_id', sa.String(), nullable=False),
+        sa.Column('version', sa.Integer(), nullable=False, server_default='1'),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
+        sa.PrimaryKeyConstraint('id')
+    )
+    
+    # Indexes for prompts
+    op.create_index('ix_prompts_group_id', 'prompts', ['group_id'], unique=False)
+    op.create_index('ix_prompts_user_id', 'prompts', ['user_id'], unique=False)
+    
+    # 2. Create prompt_groups table (prompt collections)
+    op.create_table(
+        'prompt_groups',
+        sa.Column('id', sa.String(), nullable=False),
+        sa.Column('name', sa.String(length=255), nullable=False),
+        sa.Column('description', sa.Text(), nullable=True),
+        sa.Column('category', sa.String(length=100), nullable=True),
+        sa.Column('command', sa.String(length=50), nullable=True),
+        sa.Column('user_id', sa.String(), nullable=False),
+        sa.Column('author_name', sa.String(length=255), nullable=True),
+        sa.Column('production_prompt_id', sa.String(), nullable=True),
+        sa.Column('is_shared', sa.Boolean(), nullable=False, server_default='false'),
+        sa.Column('is_pinned', sa.Boolean(), nullable=False, server_default='false'),
+        sa.Column('created_at', sa.BigInteger(), nullable=False),
+        sa.Column('updated_at', sa.BigInteger(), nullable=False),
+        sa.ForeignKeyConstraint(
+            ['production_prompt_id'],
+            ['prompts.id'],
+            ondelete='SET NULL'
+        ),
+        sa.PrimaryKeyConstraint('id')
+    )
+    
+    # Indexes for prompt_groups
+    op.create_index('ix_prompt_groups_name', 'prompt_groups', ['name'], unique=False)
+    op.create_index('ix_prompt_groups_category', 'prompt_groups', ['category'], unique=False)
+    op.create_index('ix_prompt_groups_command', 'prompt_groups', ['command'], unique=True)
+    op.create_index('ix_prompt_groups_user_id', 'prompt_groups', ['user_id'], unique=False)
+    op.create_index('ix_prompt_groups_is_pinned', 'prompt_groups', ['is_pinned'], unique=False)
+    
+    # 3. Add foreign key from prompts to prompt_groups
+    with op.batch_alter_table('prompts', schema=None) as batch_op:
+        batch_op.create_foreign_key(
+            'fk_prompts_group_id',
+            'prompt_groups',
+            ['group_id'],
+            ['id'],
+            ondelete='CASCADE'
+        )
+    
+    # 4. Create prompt_group_users table (role-based sharing)
+    op.create_table(
+        'prompt_group_users',
+        sa.Column('id', sa.String(), nullable=False),
+        sa.Column('prompt_group_id', sa.String(), nullable=False),
+        sa.Column('user_id', sa.String(), nullable=False),
+        sa.Column('role', sa.String(), nullable=False, server_default='viewer'),
+        sa.Column('added_at', sa.BigInteger(), nullable=False),
+        sa.Column('added_by_user_id', sa.String(), nullable=False),
+        sa.PrimaryKeyConstraint('id'),
+        sa.ForeignKeyConstraint(
+            ['prompt_group_id'], 
+            ['prompt_groups.id'], 
+            ondelete='CASCADE'
+        ),
+        sa.UniqueConstraint('prompt_group_id', 'user_id', name='uq_prompt_group_user')
+    )
+    
+    # Indexes for prompt_group_users (optimized for sharing queries)
+    op.create_index(
+        'ix_prompt_group_users_prompt_group_id',
+        'prompt_group_users',
+        ['prompt_group_id'],
+        unique=False
+    )
+    
+    op.create_index(
+        'ix_prompt_group_users_user_id',
+        'prompt_group_users',
+        ['user_id'],
+        unique=False
+    )
+    
+    # Composite index for fast access checks
+    op.create_index(
+        'ix_prompt_group_users_user_prompt',
+        'prompt_group_users',
+        ['user_id', 'prompt_group_id'],
+        unique=False
+    )
+    
+    # Optional: Index for role-based queries
+    op.create_index(
+        'ix_prompt_group_users_user_role',
+        'prompt_group_users',
+        ['user_id', 'role'],
+        unique=False
+    )
+
+
+def downgrade() -> None:
+    """Remove all prompt-related tables."""
+    
+    # Drop prompt_group_users table and indexes
+    op.drop_index('ix_prompt_group_users_user_role', table_name='prompt_group_users')
+    op.drop_index('ix_prompt_group_users_user_prompt', table_name='prompt_group_users')
+    op.drop_index('ix_prompt_group_users_user_id', table_name='prompt_group_users')
+    op.drop_index('ix_prompt_group_users_prompt_group_id', table_name='prompt_group_users')
+    op.drop_table('prompt_group_users')
+    
+    # Drop prompt_groups indexes and table
+    op.drop_index('ix_prompt_groups_is_pinned', table_name='prompt_groups')
+    op.drop_index('ix_prompt_groups_user_id', table_name='prompt_groups')
+    op.drop_index('ix_prompt_groups_command', table_name='prompt_groups')
+    op.drop_index('ix_prompt_groups_category', table_name='prompt_groups')
+    op.drop_index('ix_prompt_groups_name', table_name='prompt_groups')
+    op.drop_table('prompt_groups')
+    
+    # Drop prompts indexes and table
+    op.drop_index('ix_prompts_user_id', table_name='prompts')
+    op.drop_index('ix_prompts_group_id', table_name='prompts')
+    op.drop_table('prompts')

solace_agent_mesh/gateway/http_sse/alembic/versions/20251115_add_parent_task_id.py

@@ -0,0 +1,32 @@
+"""Add parent_task_id to tasks table
+
+Revision ID: 20251115_add_parent_task_id
+Revises: 20251108_prompt_tables_complete
+Create Date: 2025-11-15
+
+"""
+
+from collections.abc import Sequence
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "20251115_add_parent_task_id"
+down_revision: str | Sequence[str] | None = "20251108_prompt_tables_complete"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    """Add parent_task_id column to tasks table for efficient task hierarchy queries."""
+    op.add_column(
+        "tasks", sa.Column("parent_task_id", sa.String(), nullable=True)
+    )
+    op.create_index(
+        "ix_tasks_parent_task_id", "tasks", ["parent_task_id"], unique=False
+    )
+
+
+def downgrade() -> None:
+    """Remove parent_task_id column from tasks table."""
+    op.drop_index("ix_tasks_parent_task_id", table_name="tasks")
+    op.drop_column("tasks", "parent_task_id")