langchain-trigger-server 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

{langchain_trigger_server-0.3.4.dist-info → langchain_trigger_server-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-trigger-server
-Version: 0.3.4
+Version: 0.3.5
 Summary: Generic event-driven triggers framework
 Project-URL: Homepage, https://github.com/langchain-ai/open-agent-platform
 Project-URL: Repository, https://github.com/langchain-ai/open-agent-platform

langchain_trigger_server-0.3.5.dist-info/RECORD

@@ -0,0 +1,14 @@
+langchain_triggers/__init__.py,sha256=WoW9LC_FJRs42mLWq2iuM-jjPow2Rue50q2zm56Oul0,536
+langchain_triggers/app.py,sha256=PoyrD7whOJoiRVaCJTXrzprWIyR6gF1i-zwCks-Qscs,40349
+langchain_triggers/core.py,sha256=q7vHsjFuLqydWt9JxAPG4SPT4Z3uoouoqtXjTZoknwk,3669
+langchain_triggers/cron_manager.py,sha256=5cNRUE8xMGhIVBKJVJZhxGuzJTyoBepv3QmH0f9EyEg,16342
+langchain_triggers/decorators.py,sha256=ZhWgUjbl2jUbvGSlqgThebd0tPgqXoQ02D7BcKZ9aIs,4675
+langchain_triggers/auth/__init__.py,sha256=RtDKuBoKYuyHzLNpKr74cmALO0PhHlWO9Ho7k3CUYFE,349
+langchain_triggers/auth/slack_hmac.py,sha256=kiwjhTXITgQvLAtEcOv8BnnWJRJcxaQ9dXkQm3JJDQ4,2948
+langchain_triggers/database/__init__.py,sha256=8OxGLTh2VWQ-GVVFjrOOL1qdgQ9lkmjUV1racLGuk7E,135
+langchain_triggers/database/interface.py,sha256=Wu1MOl1rugFFVcDVM4nEMgyvwW5JxUCNpS3oD6EwkCQ,3716
+langchain_triggers/triggers/__init__.py,sha256=Uw1544gxzN4XDRn2RzpZ5EAG6EAF38ZYQtVvlciEsMs,146
+langchain_triggers/triggers/cron_trigger.py,sha256=YTscULtB8JesnB24IWZl0LDMkf-A9Y6dksAk7GLFJiQ,3355
+langchain_trigger_server-0.3.5.dist-info/METADATA,sha256=Ku7_dTuqu8Ab2KbwabNO9QTlWiQprwgaReuD8ARRxPU,1438
+langchain_trigger_server-0.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain_trigger_server-0.3.5.dist-info/RECORD,,

langchain_triggers/app.py

@@ -23,7 +23,7 @@ from .auth.slack_hmac import (
 )
 from .core import TriggerType
 from .cron_manager import CronTriggerManager
-from .database import TriggerDatabaseInterface, create_database
+from .database import TriggerDatabaseInterface
 from .decorators import TriggerTemplate
 
 logger = logging.getLogger(__name__)
@@ -68,17 +68,20 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
             return await call_next(request)
 
         try:
-            # Run mandatory custom authentication
             identity = await self.auth_handler({}, dict(request.headers))
-
-            if not identity or not identity.get("identity"):
+            if (
+                not identity
+                or not identity.get("identity")
+                or not identity.get("tenant_id")
+            ):
+                logger.error(
+                    f"Authentication failed: missing required fields (identity={bool(identity.get('identity') if identity else None)}, tenant_id={bool(identity.get('tenant_id') if identity else None)})"
+                )
                 return Response(
-                    content='{"detail": "Authentication required"}',
+                    content='{"detail": "Authentication required - identity and tenant_id must be provided"}',
                     status_code=401,
                     media_type="application/json",
                 )
-
-            # Store identity in request state for endpoints to access
             request.state.current_user = identity
 
         except Exception as e:
@@ -105,9 +108,7 @@ class TriggerServer:
     def __init__(
         self,
         auth_handler: Callable,
-        database: TriggerDatabaseInterface | None = None,
-        database_type: str | None = "supabase",
-        **database_kwargs: Any,
+        database: TriggerDatabaseInterface,
     ):
         # Configure uvicorn logging to use consistent formatting
         self._configure_uvicorn_logging()
@@ -117,15 +118,7 @@ class TriggerServer:
             description="Event-driven triggers framework",
             version="0.1.0",
         )
-
-        # Configure database: allow either instance injection or factory creation
-        # Defaults to Supabase for backward compatibility
-        if database and database_type != "supabase":
-            raise ValueError("Provide either 'database' or 'database_type', not both")
-        if database is not None:
-            self.database = database
-        else:
-            self.database = create_database(database_type, **database_kwargs)
+        self.database = database
         self.auth_handler = auth_handler
 
         # LangGraph configuration
@@ -286,14 +279,15 @@ class TriggerServer:
         async def api_list_registrations(
             current_user: dict[str, Any] = Depends(get_current_user),
         ) -> dict[str, Any]:
-            """List user's trigger registrations (user-scoped)."""
+            """List user's trigger registrations (user and tenant-scoped)."""
             try:
                 user_id = current_user["identity"]
+                tenant_id = current_user["tenant_id"]
 
                 # Get user's trigger registrations with linked agents in a single query
                 user_registrations = (
                     await self.database.get_user_trigger_registrations_with_agents(
-                        user_id
+                        user_id, tenant_id
                     )
                 )
 
@@ -329,6 +323,7 @@ class TriggerServer:
                 logger.info(f"Registration payload received: {payload}")
 
                 user_id = current_user["identity"]
+                tenant_id = current_user["tenant_id"]
                 trigger_id = payload.get("type")
                 if not trigger_id:
                     raise HTTPException(
@@ -340,7 +335,6 @@ class TriggerServer:
                     raise HTTPException(
                         status_code=400, detail=f"Unknown trigger type: {trigger_id}"
                     )
-                client_metadata = payload.pop("metadata", None)
 
                 # Parse payload into registration model first
                 try:
@@ -350,11 +344,12 @@ class TriggerServer:
                         status_code=400, detail=f"Invalid payload for trigger: {str(e)}"
                     )
 
-                # Check for duplicate registration based on resource data within this user's scope
+                # Check for duplicate registration based on resource data within this user's tenant scope
                 resource_dict = registration_instance.model_dump()
                 existing_registration = (
                     await self.database.find_user_registration_by_resource(
                         user_id=user_id,
+                        tenant_id=tenant_id,
                         template_id=trigger.id,
                         resource_data=resource_dict,
                     )
@@ -386,16 +381,12 @@ class TriggerServer:
 
                 resource_dict = registration_instance.model_dump()
 
-                merged_metadata = {}
-                if client_metadata:
-                    merged_metadata["client_metadata"] = client_metadata
-                merged_metadata.update(result.metadata)
-
                 registration = await self.database.create_trigger_registration(
                     user_id=user_id,
+                    tenant_id=tenant_id,
                     template_id=trigger.id,
                     resource=resource_dict,
-                    metadata=merged_metadata,
+                    metadata=result.metadata,
                 )
 
                 if not registration:
@@ -427,8 +418,9 @@ class TriggerServer:
             """Delete a trigger registration."""
             try:
                 user_id = current_user["identity"]
+                tenant_id = current_user["tenant_id"]
                 success = await self.database.delete_trigger_registration(
-                    registration_id, user_id
+                    registration_id, user_id, tenant_id
                 )
                 if not success:
                     raise HTTPException(
@@ -450,10 +442,11 @@ class TriggerServer:
             """List agents linked to this registration."""
             try:
                 user_id = current_user["identity"]
+                tenant_id = current_user["tenant_id"]
 
                 # Get the specific trigger registration
                 trigger = await self.database.get_trigger_registration(
-                    registration_id, user_id
+                    registration_id, user_id, tenant_id
                 )
                 if not trigger:
                     raise HTTPException(
@@ -490,10 +483,11 @@ class TriggerServer:
                     field_selection = None
 
                 user_id = current_user["identity"]
+                tenant_id = current_user["tenant_id"]
 
                 # Verify the trigger registration exists and belongs to the user
                 registration = await self.database.get_trigger_registration(
-                    registration_id, user_id
+                    registration_id, user_id, tenant_id
                 )
                 if not registration:
                     raise HTTPException(
@@ -537,10 +531,11 @@ class TriggerServer:
             """Remove an agent from a trigger registration."""
             try:
                 user_id = current_user["identity"]
+                tenant_id = current_user["tenant_id"]
 
                 # Verify the trigger registration exists and belongs to the user
                 registration = await self.database.get_trigger_registration(
-                    registration_id, user_id
+                    registration_id, user_id, tenant_id
                 )
                 if not registration:
                     raise HTTPException(
@@ -578,10 +573,11 @@ class TriggerServer:
             """Manually execute a cron trigger registration immediately."""
             try:
                 user_id = current_user["identity"]
+                tenant_id = current_user["tenant_id"]
 
                 # Verify the trigger registration exists and belongs to the user
                 registration = await self.database.get_trigger_registration(
-                    registration_id, user_id
+                    registration_id, user_id, tenant_id
                 )
                 if not registration:
                     raise HTTPException(
@@ -751,11 +747,7 @@ class TriggerServer:
                     # Ensure agent_id and user_id are strings for JSON serialization
                     agent_id_str = str(agent_id)
                     user_id_str = str(result.registration["user_id"])
-                    tenant_id_str = str(
-                        result.registration.get("metadata", {})
-                        .get("client_metadata", {})
-                        .get("tenant_id")
-                    )
+                    tenant_id_str = str(result.registration["tenant_id"])
 
                     agent_input = {"messages": [{"role": "human", "content": message}]}
 

langchain_triggers/core.py

@@ -97,12 +97,6 @@ class TriggerRegistrationResult(BaseModel):
         if self.create_registration and not self.metadata:
             self.metadata = {}  # Allow empty metadata for create_registration=True
 
-        if "client_metadata" in self.metadata:
-            raise ValueError(
-                "The 'client_metadata' key is reserved for client-provided metadata. "
-                "Registration handlers must not use this key in their metadata."
-            )
-
         if not self.create_registration and (
             not self.response_body or not self.status_code
         ):

langchain_triggers/cron_manager.py

@@ -285,9 +285,7 @@ class CronTriggerManager:
         user_id = registration["user_id"]
         template_id = registration.get("template_id")
         template_id = str(template_id) if template_id is not None else None
-        tenant_id = (
-            registration.get("metadata", {}).get("client_metadata", {}).get("tenant_id")
-        )
+        tenant_id = str(registration.get("tenant_id"))
 
         # Get agent links
         agent_links = await self.trigger_server.database.get_agents_for_trigger(

langchain_triggers/database/__init__.py

@@ -1,16 +1,5 @@
 """Database module for trigger operations."""
 
 from .interface import TriggerDatabaseInterface
-from .supabase import SupabaseTriggerDatabase
 
-
-def create_database(database_type: str, **kwargs) -> TriggerDatabaseInterface:
-    """Factory function to create database implementation."""
-
-    if database_type == "supabase":
-        return SupabaseTriggerDatabase(**kwargs)
-    else:
-        raise ValueError(f"Unknown database type: {database_type}")
-
-
-__all__ = ["TriggerDatabaseInterface", "SupabaseTriggerDatabase", "create_database"]
+__all__ = ["TriggerDatabaseInterface"]

langchain_triggers/database/interface.py

@@ -35,28 +35,33 @@ class TriggerDatabaseInterface(ABC):
 
     @abstractmethod
     async def create_trigger_registration(
-        self, user_id: str, template_id: str, resource: dict, metadata: dict = None
+        self,
+        user_id: str,
+        tenant_id: str,
+        template_id: str,
+        resource: dict,
+        metadata: dict = None,
     ) -> dict[str, Any] | None:
         """Create a new trigger registration for a user."""
         pass
 
     @abstractmethod
     async def get_user_trigger_registrations(
-        self, user_id: str
+        self, user_id: str, tenant_id: str
     ) -> list[dict[str, Any]]:
-        """Get all trigger registrations for a user."""
+        """Get all trigger registrations for a user within a tenant."""
         pass
 
     @abstractmethod
     async def get_user_trigger_registrations_with_agents(
-        self, user_id: str
+        self, user_id: str, tenant_id: str
     ) -> list[dict[str, Any]]:
-        """Get all trigger registrations for a user with linked agents in a single query."""
+        """Get all trigger registrations for a user with linked agents in a single query within a tenant."""
         pass
 
     @abstractmethod
     async def get_trigger_registration(
-        self, registration_id: str, user_id: str = None
+        self, registration_id: str, user_id: str, tenant_id: str
     ) -> dict[str, Any] | None:
         """Get a specific trigger registration."""
         pass
@@ -70,9 +75,13 @@ class TriggerDatabaseInterface(ABC):
 
     @abstractmethod
     async def find_user_registration_by_resource(
-        self, user_id: str, template_id: str, resource_data: dict[str, Any]
+        self,
+        user_id: str,
+        tenant_id: str,
+        template_id: str,
+        resource_data: dict[str, Any],
     ) -> dict[str, Any] | None:
-        """Find trigger registration by matching resource data for a specific user."""
+        """Find trigger registration by matching resource data for a specific user within a tenant."""
         pass
 
     @abstractmethod
@@ -80,16 +89,9 @@ class TriggerDatabaseInterface(ABC):
         """Get all registrations for a specific trigger template."""
         pass
 
-    @abstractmethod
-    async def update_trigger_metadata(
-        self, registration_id: str, metadata_updates: dict, user_id: str = None
-    ) -> bool:
-        """Update metadata for a trigger registration."""
-        pass
-
     @abstractmethod
     async def delete_trigger_registration(
-        self, registration_id: str, user_id: str = None
+        self, registration_id: str, user_id: str, tenant_id: str
     ) -> bool:
         """Delete a trigger registration."""
         pass
@@ -120,20 +122,3 @@ class TriggerDatabaseInterface(ABC):
     ) -> list[dict[str, Any]]:
         """Get all agent links for a trigger registration with field_selection."""
         pass
-
-    @abstractmethod
-    async def get_triggers_for_agent(self, agent_id: str) -> list[dict[str, Any]]:
-        """Get all trigger registrations linked to an agent."""
-        pass
-
-    # ========== Helper Methods ==========
-
-    @abstractmethod
-    async def get_user_from_token(self, token: str) -> str | None:
-        """Extract user ID from authentication token."""
-        pass
-
-    @abstractmethod
-    async def get_user_by_email(self, email: str) -> str | None:
-        """Get user ID by email from trigger registrations."""
-        pass

langchain_trigger_server-0.3.4.dist-info/RECORD

@@ -1,15 +0,0 @@
-langchain_triggers/__init__.py,sha256=WoW9LC_FJRs42mLWq2iuM-jjPow2Rue50q2zm56Oul0,536
-langchain_triggers/app.py,sha256=-VytRXkAPI8qm-fbMJMbQ52Qt8WC2nKBgL_8FGJaFTM,40468
-langchain_triggers/core.py,sha256=6r_91UWt7c26TVqkDxHc2xjmaQl42g-iFHGEWuDo0gs,3929
-langchain_triggers/cron_manager.py,sha256=PueW_z7gdkSza9J05W1VV2OxsfqvodMo7ZlAQJKMvpI,16408
-langchain_triggers/decorators.py,sha256=ZhWgUjbl2jUbvGSlqgThebd0tPgqXoQ02D7BcKZ9aIs,4675
-langchain_triggers/auth/__init__.py,sha256=RtDKuBoKYuyHzLNpKr74cmALO0PhHlWO9Ho7k3CUYFE,349
-langchain_triggers/auth/slack_hmac.py,sha256=kiwjhTXITgQvLAtEcOv8BnnWJRJcxaQ9dXkQm3JJDQ4,2948
-langchain_triggers/database/__init__.py,sha256=B1I1qmVr3U1CSf0VkjxsL4W5QGda5T7uB_CsJq6yBF4,535
-langchain_triggers/database/interface.py,sha256=jpADOOwcBQo1ZichgiZVaOvfZqEqVVo8Ea7ATWWTSBE,4283
-langchain_triggers/database/supabase.py,sha256=zi_75GbqRvzzlXd5EgfYof4h6vHWOLS4I1759wvY9kQ,17009
-langchain_triggers/triggers/__init__.py,sha256=Uw1544gxzN4XDRn2RzpZ5EAG6EAF38ZYQtVvlciEsMs,146
-langchain_triggers/triggers/cron_trigger.py,sha256=YTscULtB8JesnB24IWZl0LDMkf-A9Y6dksAk7GLFJiQ,3355
-langchain_trigger_server-0.3.4.dist-info/METADATA,sha256=FJuy7Q06X25o4JwhcS4yldyOAvsDBHdycR6utvhIgss,1438
-langchain_trigger_server-0.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langchain_trigger_server-0.3.4.dist-info/RECORD,,

langchain_triggers/database/supabase.py

@@ -1,471 +0,0 @@
-"""Supabase implementation of trigger database interface."""
-
-import base64
-import hashlib
-import logging
-import os
-from typing import Any
-
-from cryptography.hazmat.backends import default_backend
-from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-from supabase import create_client
-
-from .interface import TriggerDatabaseInterface
-
-logger = logging.getLogger(__name__)
-
-
-class SupabaseTriggerDatabase(TriggerDatabaseInterface):
-    """Supabase implementation of trigger database operations."""
-
-    def __init__(self, supabase_url: str = None, supabase_key: str = None):
-        self.supabase_url = supabase_url or os.getenv("SUPABASE_URL")
-        self.supabase_key = supabase_key or os.getenv("SUPABASE_KEY")
-
-        if not self.supabase_url or not self.supabase_key:
-            raise ValueError(
-                "SUPABASE_URL and SUPABASE_KEY environment variables are required"
-            )
-
-        self.client = create_client(self.supabase_url, self.supabase_key)
-
-        # Get encryption key for API key decryption - required
-        self.encryption_key = os.getenv("SECRETS_ENCRYPTION_KEY")
-        if not self.encryption_key:
-            raise ValueError("SECRETS_ENCRYPTION_KEY environment variable is required")
-
-        logger.info("Initialized SupabaseTriggerDatabase")
-
-    def _decrypt_secret(self, encrypted_secret: str) -> str:
-        """Decrypt an encrypted secret using AES-256-GCM to match OAP Node.js implementation."""
-        try:
-            # Decode the base64 encoded encrypted data
-            combined = base64.b64decode(encrypted_secret)
-
-            # Constants from Node.js implementation
-            IV_LENGTH = 12  # 96 bits
-            TAG_LENGTH = 16  # 128 bits
-
-            # Minimum length check
-            if len(combined) < IV_LENGTH + TAG_LENGTH + 1:
-                raise ValueError(
-                    "Invalid encrypted secret format: too short or malformed"
-                )
-
-            # Extract IV, encrypted data, and auth tag
-            iv = combined[:IV_LENGTH]
-            tag = combined[-TAG_LENGTH:]
-            encrypted_data = combined[IV_LENGTH:-TAG_LENGTH]
-
-            # Derive key using SHA-256 hash (same as Node.js deriveKey function)
-            key = hashlib.sha256(self.encryption_key.encode()).digest()
-
-            # Create AES-GCM cipher
-            cipher = Cipher(
-                algorithms.AES(key), modes.GCM(iv, tag), backend=default_backend()
-            )
-            decryptor = cipher.decryptor()
-
-            # Decrypt the data
-            decrypted_data = decryptor.update(encrypted_data) + decryptor.finalize()
-
-            return decrypted_data.decode("utf-8")
-        except Exception as e:
-            logger.error(f"Error decrypting secret: {e}")
-            raise ValueError("Failed to decrypt API key")
-
-    # ========== Trigger Templates ==========
-
-    async def create_trigger_template(
-        self,
-        id: str,
-        provider: str,
-        name: str,
-        description: str = None,
-        registration_schema: dict = None,
-    ) -> dict[str, Any] | None:
-        """Create a new trigger template."""
-        try:
-            data = {
-                "id": id,
-                "provider": provider,
-                "name": name,
-                "description": description,
-                "registration_schema": registration_schema or {},
-            }
-
-            response = self.client.table("trigger_templates").insert(data).execute()
-            return response.data[0] if response.data else None
-
-        except Exception as e:
-            logger.error(f"Error creating trigger template: {e}")
-            return None
-
-    async def get_trigger_templates(self) -> list[dict[str, Any]]:
-        """Get all available trigger templates."""
-        try:
-            response = self.client.table("trigger_templates").select("*").execute()
-            return response.data or []
-        except Exception as e:
-            logger.error(f"Error getting trigger templates: {e}")
-            return []
-
-    async def get_trigger_template(self, id: str) -> dict[str, Any] | None:
-        """Get a specific trigger template by ID."""
-        try:
-            response = (
-                self.client.table("trigger_templates")
-                .select("*")
-                .eq("id", id)
-                .single()
-                .execute()
-            )
-            return response.data if response.data else None
-        except Exception as e:
-            # Don't log as error if template just doesn't exist (expected on first startup)
-            if (
-                "no rows returned" in str(e).lower()
-                or "multiple (or no) rows returned" in str(e).lower()
-            ):
-                logger.debug(f"Trigger template {id} not found in database")
-            else:
-                logger.error(f"Error getting trigger template {id}: {e}")
-            return None
-
-    # ========== Trigger Registrations ==========
-
-    async def create_trigger_registration(
-        self, user_id: str, template_id: str, resource: dict, metadata: dict = None
-    ) -> dict[str, Any] | None:
-        """Create a new trigger registration for a user."""
-        try:
-            # Verify template exists
-            template = await self.get_trigger_template(template_id)
-            if not template:
-                logger.error(f"Template not found for ID: {template_id}")
-                return None
-
-            data = {
-                "user_id": user_id,
-                "template_id": template_id,
-                "resource": resource,
-                "metadata": metadata or {},
-                "status": "active",
-            }
-
-            response = self.client.table("trigger_registrations").insert(data).execute()
-            return response.data[0] if response.data else None
-
-        except Exception as e:
-            logger.exception(f"Error creating trigger registration: {e}")
-            return None
-
-    async def get_user_trigger_registrations(
-        self, user_id: str
-    ) -> list[dict[str, Any]]:
-        """Get all trigger registrations for a user."""
-        try:
-            response = (
-                self.client.table("trigger_registrations")
-                .select("""
-                *,
-                trigger_templates(id, name, description)
-            """)
-                .eq("user_id", user_id)
-                .order("created_at", desc=True)
-                .execute()
-            )
-
-            return response.data or []
-        except Exception as e:
-            logger.error(f"Error getting user trigger registrations: {e}")
-            return []
-
-    async def get_user_trigger_registrations_with_agents(
-        self, user_id: str
-    ) -> list[dict[str, Any]]:
-        """Get all trigger registrations for a user with linked agents in a single query."""
-        try:
-            response = (
-                self.client.table("trigger_registrations")
-                .select("""
-                *,
-                trigger_templates(id, name, description),
-                agent_trigger_links(agent_id)
-            """)
-                .eq("user_id", user_id)
-                .order("created_at", desc=True)
-                .execute()
-            )
-
-            # Process the results to extract linked agent IDs
-            if response.data:
-                for registration in response.data:
-                    # Extract agent IDs from the agent_trigger_links
-                    agent_links = registration.get("agent_trigger_links", [])
-                    linked_agent_ids = [
-                        link.get("agent_id")
-                        for link in agent_links
-                        if link.get("agent_id")
-                    ]
-                    registration["linked_agent_ids"] = linked_agent_ids
-
-                    # Clean up the raw agent_trigger_links data as it's no longer needed
-                    registration.pop("agent_trigger_links", None)
-
-            return response.data or []
-        except Exception as e:
-            logger.error(f"Error getting user trigger registrations with agents: {e}")
-            return []
-
-    async def get_trigger_registration(
-        self, registration_id: str, user_id: str = None
-    ) -> dict[str, Any] | None:
-        """Get a specific trigger registration."""
-        try:
-            query = (
-                self.client.table("trigger_registrations")
-                .select("*")
-                .eq("id", registration_id)
-            )
-            if user_id:
-                query = query.eq("user_id", user_id)
-
-            response = query.single().execute()
-            return response.data if response.data else None
-        except Exception as e:
-            logger.error(f"Error getting trigger registration {registration_id}: {e}")
-            return None
-
-    async def update_trigger_metadata(
-        self, registration_id: str, metadata_updates: dict, user_id: str = None
-    ) -> bool:
-        """Update metadata for a trigger registration."""
-        try:
-            # Get current registration to merge metadata
-            current = await self.get_trigger_registration(registration_id, user_id)
-            if not current:
-                return False
-
-            # Merge existing metadata with updates
-            current_metadata = current.get("metadata", {})
-            updated_metadata = {**current_metadata, **metadata_updates}
-
-            query = (
-                self.client.table("trigger_registrations")
-                .update({"metadata": updated_metadata, "updated_at": "NOW()"})
-                .eq("id", registration_id)
-            )
-
-            if user_id:
-                query = query.eq("user_id", user_id)
-
-            response = query.execute()
-            return bool(response.data)
-
-        except Exception as e:
-            logger.error(f"Error updating trigger metadata: {e}")
-            return False
-
-    async def delete_trigger_registration(
-        self, registration_id: str, user_id: str = None
-    ) -> bool:
-        """Delete a trigger registration."""
-        try:
-            query = (
-                self.client.table("trigger_registrations")
-                .delete()
-                .eq("id", registration_id)
-            )
-            if user_id:
-                query = query.eq("user_id", user_id)
-
-            query.execute()
-            return True  # Delete operations don't return data
-
-        except Exception as e:
-            logger.error(f"Error deleting trigger registration: {e}")
-            return False
-
-    async def find_registration_by_resource(
-        self, template_id: str, resource_data: dict[str, Any]
-    ) -> dict[str, Any] | None:
-        """Find trigger registration by matching resource data."""
-        try:
-            # Build query to match against trigger_registrations with template_id filter
-            query = (
-                self.client.table("trigger_registrations")
-                .select("*, trigger_templates(id, name, description)")
-                .eq("template_id", template_id)
-            )
-
-            # Add resource field matches
-            for field, value in resource_data.items():
-                query = query.eq(f"resource->>{field}", value)
-
-            response = query.execute()
-
-            if response.data:
-                return response.data[0]  # Return first match
-            return None
-
-        except Exception as e:
-            logger.error(f"Error finding registration by resource: {e}")
-            return None
-
-    async def find_user_registration_by_resource(
-        self, user_id: str, template_id: str, resource_data: dict[str, Any]
-    ) -> dict[str, Any] | None:
-        """Find trigger registration by matching resource data for a specific user."""
-        try:
-            # Build query to match against trigger_registrations with template_id and user_id filter
-            query = (
-                self.client.table("trigger_registrations")
-                .select("*, trigger_templates(id, name, description)")
-                .eq("template_id", template_id)
-                .eq("user_id", user_id)
-            )
-
-            # Add resource field matches
-            for field, value in resource_data.items():
-                query = query.eq(f"resource->>{field}", value)
-
-            response = query.execute()
-
-            if response.data:
-                return response.data[0]  # Return first match
-            return None
-
-        except Exception as e:
-            logger.error(f"Error finding user registration by resource: {e}")
-            return None
-
-    async def get_all_registrations(self, template_id: str) -> list[dict[str, Any]]:
-        """Get all registrations for a specific trigger template."""
-        try:
-            response = (
-                self.client.table("trigger_registrations")
-                .select("*, trigger_templates(id, name, description)")
-                .eq("template_id", template_id)
-                .execute()
-            )
-
-            return response.data or []
-        except Exception as e:
-            logger.error(
-                f"Error getting all registrations for template {template_id}: {e}"
-            )
-            return []
-
-    # ========== Agent-Trigger Links ==========
-
-    async def link_agent_to_trigger(
-        self,
-        agent_id: str,
-        registration_id: str,
-        created_by: str,
-        field_selection: dict[str, bool] | None = None,
-    ) -> bool:
-        """Link an agent to a trigger registration with optional field selection."""
-        try:
-            data = {
-                "agent_id": agent_id,
-                "registration_id": registration_id,
-                "created_by": created_by,
-                "field_selection": field_selection,
-            }
-
-            response = self.client.table("agent_trigger_links").insert(data).execute()
-            return bool(response.data)
-
-        except Exception as e:
-            logger.error(f"Error linking agent to trigger: {e}")
-            return False
-
-    async def unlink_agent_from_trigger(
-        self, agent_id: str, registration_id: str
-    ) -> bool:
-        """Unlink an agent from a trigger registration."""
-        try:
-            (
-                self.client.table("agent_trigger_links")
-                .delete()
-                .eq("agent_id", agent_id)
-                .eq("registration_id", registration_id)
-                .execute()
-            )
-
-            return True  # Delete operations don't return data
-
-        except Exception as e:
-            logger.error(f"Error unlinking agent from trigger: {e}")
-            return False
-
-    async def get_agents_for_trigger(
-        self, registration_id: str
-    ) -> list[dict[str, Any]]:
-        """Get all agent links for a trigger registration with field_selection."""
-        try:
-            response = (
-                self.client.table("agent_trigger_links")
-                .select("agent_id, field_selection")
-                .eq("registration_id", registration_id)
-                .execute()
-            )
-
-            return response.data or []
-
-        except Exception as e:
-            logger.error(f"Error getting agents for trigger: {e}")
-            return []
-
-    async def get_triggers_for_agent(self, agent_id: str) -> list[dict[str, Any]]:
-        """Get all trigger registrations linked to an agent."""
-        try:
-            response = (
-                self.client.table("agent_trigger_links")
-                .select("""
-                registration_id,
-                trigger_registrations(
-                    *,
-                    trigger_templates(id, name, description)
-                )
-            """)
-                .eq("agent_id", agent_id)
-                .execute()
-            )
-
-            return [row["trigger_registrations"] for row in response.data or []]
-
-        except Exception as e:
-            logger.error(f"Error getting triggers for agent: {e}")
-            return []
-
-    # ========== Helper Methods ==========
-
-    async def get_user_from_token(self, token: str) -> str | None:
-        """Extract user ID from JWT token via Supabase auth."""
-        try:
-            client = self._create_user_client(token)
-            response = client.auth.get_user(token)
-            return response.user.id if response.user else None
-        except Exception as e:
-            logger.error(f"Error getting user from token: {e}")
-            return None
-
-    async def get_user_by_email(self, email: str) -> str | None:
-        """Get user ID by email from trigger registrations."""
-        try:
-            response = (
-                self.client.table("trigger_registrations")
-                .select("user_id")
-                .eq("resource->>email", email)
-                .limit(1)
-                .execute()
-            )
-
-            return response.data[0]["user_id"] if response.data else None
-
-        except Exception as e:
-            logger.error(f"Error getting user by email: {e}")
-            return None