langchain-trigger-server 0.3.4__tar.gz → 0.3.6__tar.gz

{langchain_trigger_server-0.3.4 → langchain_trigger_server-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-trigger-server
-Version: 0.3.4
+Version: 0.3.6
 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.4 → langchain_trigger_server-0.3.6}/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_trigger_server-0.3.4 → langchain_trigger_server-0.3.6}/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_trigger_server-0.3.4 → langchain_trigger_server-0.3.6}/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(
@@ -338,7 +336,7 @@ class CronTriggerManager:
             f"agents_linked={len(agent_links)}"
         )
 
-        for message in messages:
+        for _message in messages:
             for agent_link in agent_links:
                 agent_id = (
                     agent_link
@@ -357,7 +355,7 @@ class CronTriggerManager:
                     "messages": [
                         {
                             "role": "human",
-                            "content": f"ACTION: triggering cron from langchain-trigger-server\nCURRENT TIME: {current_time_str}\n\n{message}",
+                            "content": f"Cron trigger fired at {current_time_str}",
                         }
                     ]
                 }

langchain_trigger_server-0.3.6/langchain_triggers/database/__init__.py

@@ -0,0 +1,5 @@
+"""Database module for trigger operations."""
+
+from .interface import TriggerDatabaseInterface
+
+__all__ = ["TriggerDatabaseInterface"]

{langchain_trigger_server-0.3.4 → langchain_trigger_server-0.3.6}/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 → langchain_trigger_server-0.3.6}/langchain_triggers/triggers/cron_trigger.py

@@ -84,12 +84,7 @@ async def cron_poll_handler(
 
     Produces a simple time-based message for linked agents.
     """
-    current_time = datetime.utcnow()
-    current_time_str = current_time.strftime("%A, %B %d, %Y at %H:%M UTC")
-    message = (
-        "ACTION: triggering cron from langchain-trigger-server\n"
-        f"CURRENT TIME: {current_time_str}"
-    )
+    message = "Cron trigger fired"
     return TriggerHandlerResult(
         invoke_agent=True,
         agent_messages=[message],

{langchain_trigger_server-0.3.4 → langchain_trigger_server-0.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langchain-trigger-server"
-version = "0.3.4"
+version = "0.3.6"
 description = "Generic event-driven triggers framework"
 readme = "README.md"
 requires-python = ">=3.11"

{langchain_trigger_server-0.3.4 → langchain_trigger_server-0.3.6}/tests/unit/test_trigger_server_api.py

@@ -18,7 +18,10 @@ async def mock_auth_handler(request_body, headers):
         return None
     # Extract user ID from Bearer token for testing
     token = auth_header.replace("Bearer ", "")
-    return {"identity": f"test_user_{token}"}
+    return {
+        "identity": f"test_user_{token}",
+        "tenant_id": f"test_tenant_{token}",
+    }
 
 
 class TestRegistration(BaseModel):
@@ -61,11 +64,12 @@ class MockDatabase:
         return self.templates
 
     async def create_trigger_registration(
-        self, user_id, template_id, resource, metadata
+        self, user_id, tenant_id, template_id, resource, metadata
     ):
         registration = {
             "id": f"reg_{len(self.registrations)}",
             "user_id": user_id,
+            "tenant_id": tenant_id,
             "template_id": template_id,
             "resource": resource,
             "metadata": metadata,
@@ -75,7 +79,7 @@ class MockDatabase:
         self.registrations.append(registration)
         return registration
 
-    async def get_user_trigger_registrations_with_agents(self, user_id):
+    async def get_user_trigger_registrations_with_agents(self, user_id, tenant_id):
         return [
             {
                 **reg,
@@ -83,21 +87,39 @@ class MockDatabase:
                 "linked_agent_ids": reg.get("linked_agent_ids", []),
             }
             for reg in self.registrations
-            if reg["user_id"] == user_id
+            if reg["user_id"] == user_id and reg["tenant_id"] == tenant_id
         ]
 
-    async def get_trigger_registration(self, registration_id, user_id=None):
+    async def get_trigger_registration(self, registration_id, user_id, tenant_id):
         for reg in self.registrations:
             if reg["id"] == registration_id:
-                if user_id is None or reg["user_id"] == user_id:
+                if reg["user_id"] == user_id and reg["tenant_id"] == tenant_id:
                     return reg
         return None
 
     async def find_user_registration_by_resource(
-        self, user_id, template_id, resource_data
+        self, user_id, tenant_id, template_id, resource_data
     ):
         return None  # No duplicates for testing
 
+    async def delete_trigger_registration(self, registration_id, user_id, tenant_id):
+        from fastapi import HTTPException
+
+        initial_count = len(self.registrations)
+        self.registrations = [
+            reg
+            for reg in self.registrations
+            if not (
+                reg["id"] == registration_id
+                and reg["user_id"] == user_id
+                and reg["tenant_id"] == tenant_id
+            )
+        ]
+        deleted = len(self.registrations) < initial_count
+        if not deleted:
+            raise HTTPException(status_code=404, detail="Registration not found")
+        return deleted
+
     async def link_agent_to_trigger(
         self, agent_id, registration_id, created_by, field_selection=None
     ):
@@ -252,6 +274,7 @@ async def test_list_registrations_for_user(trigger_server):
     # Create a registration
     await trigger_server.database.create_trigger_registration(
         user_id="test_user_token1",
+        tenant_id="test_tenant_token1",
         template_id="test_trigger",
         resource={"url": "https://example.com"},
         metadata={"test": "value"},
@@ -277,6 +300,7 @@ async def test_link_agent_to_trigger(trigger_server):
     # Create a registration first
     reg = await trigger_server.database.create_trigger_registration(
         user_id="test_user_token1",
+        tenant_id="test_tenant_token1",
         template_id="test_trigger",
         resource={"url": "https://example.com"},
         metadata={},
@@ -304,6 +328,7 @@ async def test_unlink_agent_from_trigger(trigger_server):
     # Create a registration and link an agent
     reg = await trigger_server.database.create_trigger_registration(
         user_id="test_user_token1",
+        tenant_id="test_tenant_token1",
         template_id="test_trigger",
         resource={"url": "https://example.com"},
         metadata={},
@@ -333,12 +358,14 @@ async def test_user_isolation(trigger_server):
     # Create registrations for two different users
     await trigger_server.database.create_trigger_registration(
         user_id="test_user_token1",
+        tenant_id="test_tenant_token1",
         template_id="test_trigger",
         resource={"url": "https://example.com"},
         metadata={},
     )
     await trigger_server.database.create_trigger_registration(
         user_id="test_user_token2",
+        tenant_id="test_tenant_token2",
         template_id="test_trigger",
         resource={"url": "https://other.com"},
         metadata={},
@@ -368,8 +395,8 @@ async def test_user_isolation(trigger_server):
 
 
 @pytest.mark.asyncio
-async def test_client_metadata_storage(trigger_server):
-    """Test that client-provided metadata is stored as client_metadata."""
+async def test_metadata_storage(trigger_server):
+    """Test that handler metadata is properly stored."""
     from langchain_triggers import TriggerRegistrationResult, TriggerTemplate
 
     async def test_registration_handler(request, user_id, auth_client, registration):
@@ -394,7 +421,6 @@ async def test_client_metadata_storage(trigger_server):
             json={
                 "type": "test_metadata_trigger",
                 "name": "test",
-                "metadata": {"tenant_id": "org-123"},
             },
         )
 
@@ -405,46 +431,70 @@ async def test_client_metadata_storage(trigger_server):
         # Verify metadata in API response
         registration_id = data["data"]["id"]
         metadata = data["data"]["metadata"]
-        assert metadata["client_metadata"]["tenant_id"] == "org-123"
         assert metadata["handler_data"] == "from_handler"
 
         # Verify metadata persisted in database
         db_registration = await trigger_server.database.get_trigger_registration(
-            registration_id, user_id="test_user_token1"
+            registration_id, user_id="test_user_token1", tenant_id="test_tenant_token1"
         )
         assert db_registration is not None
         db_metadata = db_registration["metadata"]
-        assert db_metadata["client_metadata"]["tenant_id"] == "org-123"
         assert db_metadata["handler_data"] == "from_handler"
 
 
 @pytest.mark.asyncio
-async def test_handler_cannot_use_client_metadata_key(trigger_server):
-    """Test that handlers cannot use the reserved client_metadata key."""
-    from langchain_triggers import TriggerRegistrationResult, TriggerTemplate
-
-    async def bad_handler(request, user_id, auth_client, registration):
-        # Handler tries to use reserved key
-        return TriggerRegistrationResult(metadata={"client_metadata": "not allowed"})
-
-    test_trigger = TriggerTemplate(
-        id="test_bad_handler",
-        provider="test",
-        name="Test Bad Handler",
-        description="Tests validation",
-        registration_model=TestRegistration,
-        registration_handler=bad_handler,
-        trigger_handler=dummy_trigger_handler,
+async def test_tenant_isolation(trigger_server):
+    """Test strict tenant isolation across all APIs."""
+    tenant_a_reg = await trigger_server.database.create_trigger_registration(
+        user_id="test_user_tenant_a",
+        tenant_id="test_tenant_tenant_a",
+        template_id="test_trigger",
+        resource={"url": "https://tenant-a.com"},
+        metadata={},
+    )
+    tenant_b_reg = await trigger_server.database.create_trigger_registration(
+        user_id="test_user_tenant_b",
+        tenant_id="test_tenant_tenant_b",
+        template_id="test_trigger",
+        resource={"url": "https://tenant-b.com"},
+        metadata={},
     )
-    trigger_server.add_trigger(test_trigger)
 
     transport = ASGITransport(app=trigger_server.app, raise_app_exceptions=True)
     async with AsyncClient(base_url="http://localhost", transport=transport) as client:
+        response = await client.get(
+            "/v1/triggers/registrations", headers={"Authorization": "Bearer tenant_a"}
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["data"]) == 1
+        assert data["data"][0]["id"] == tenant_a_reg["id"]
+
+        response = await client.get(
+            "/v1/triggers/registrations", headers={"Authorization": "Bearer tenant_b"}
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert len(data["data"]) == 1
+        assert data["data"][0]["id"] == tenant_b_reg["id"]
+
         response = await client.post(
-            "/v1/triggers/registrations",
-            headers={"Authorization": "Bearer token1"},
-            json={"type": "test_bad_handler", "name": "test"},
+            f"/v1/triggers/registrations/{tenant_a_reg['id']}/agents/agent_x",
+            headers={"Authorization": "Bearer tenant_b"},
+            json={},
+        )
+        assert response.status_code == 404
+
+        response = await client.delete(
+            f"/v1/triggers/registrations/{tenant_a_reg['id']}",
+            headers={"Authorization": "Bearer tenant_b"},
         )
+        assert response.status_code == 404
 
-        assert response.status_code == 500
-        assert "client_metadata" in response.json()["detail"]
+        response = await client.delete(
+            f"/v1/triggers/registrations/{tenant_a_reg['id']}",
+            headers={"Authorization": "Bearer tenant_a"},
+        )
+        assert response.status_code == 200
+        data = response.json()
+        assert data["success"] is True

{langchain_trigger_server-0.3.4 → langchain_trigger_server-0.3.6}/uv.lock

@@ -231,18 +231,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/02/c3/253a89ee03fc9b9682f1541728eb66db7db22148cd94f89ab22528cd1e1b/deprecation-2.1.0-py2.py3-none-any.whl", hash = "sha256:a10811591210e1fb0e768a8c25517cabeabcba6f0bf96564f8ff45189f90b14a", size = 11178, upload-time = "2020-04-20T14:23:36.581Z" },
 ]
 
-[[package]]
-name = "ecdsa"
-version = "0.19.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "six" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c0/1f/924e3caae75f471eae4b26bd13b698f6af2c44279f67af317439c2f4c46a/ecdsa-0.19.1.tar.gz", hash = "sha256:478cba7b62555866fcb3bb3fe985e06decbdb68ef55713c4e5ab98c57d508e61", size = 201793, upload-time = "2025-03-13T11:52:43.25Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/cb/a3/460c57f094a4a165c84a1341c373b0a4f5ec6ac244b998d5021aade89b77/ecdsa-0.19.1-py2.py3-none-any.whl", hash = "sha256:30638e27cf77b7e15c4c4cc1973720149e1033827cfd00661ca5c8cc0cdb24c3", size = 150607, upload-time = "2025-03-13T11:52:41.757Z" },
-]
-
 [[package]]
 name = "fastapi"
 version = "0.116.1"
@@ -393,7 +381,7 @@ wheels = [
 
 [[package]]
 name = "langchain-trigger-server"
-version = "0.3.3"
+version = "0.3.5"
 source = { editable = "." }
 dependencies = [
     { name = "apscheduler" },
@@ -404,7 +392,6 @@ dependencies = [
     { name = "langchain-auth" },
     { name = "langgraph-sdk" },
     { name = "pydantic" },
-    { name = "python-jose", extra = ["cryptography"] },
     { name = "python-multipart" },
     { name = "supabase" },
     { name = "uvicorn", extra = ["standard"] },
@@ -442,7 +429,6 @@ requires-dist = [
     { name = "pydantic", specifier = ">=2.0.0" },
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=7.0.0" },
     { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.21.0" },
-    { name = "python-jose", extras = ["cryptography"], specifier = ">=3.3.0" },
     { name = "python-multipart", specifier = ">=0.0.6" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.1.0" },
     { name = "supabase", specifier = ">=2.0.0" },
@@ -633,15 +619,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a4/71/188a50ea64c17f73ff4df5196ec1553a8f1723421eb2d1069c73bab47d78/postgrest-1.1.1-py3-none-any.whl", hash = "sha256:98a6035ee1d14288484bfe36235942c5fb2d26af6d8120dfe3efbe007859251a", size = 22366, upload-time = "2025-06-23T19:21:33.637Z" },
 ]
 
-[[package]]
-name = "pyasn1"
-version = "0.6.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ba/e9/01f1a64245b89f039897cb0130016d79f77d52669aae6ee7b159a6c4c018/pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034", size = 145322, upload-time = "2024-09-10T22:41:42.55Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/f1/d6a797abb14f6283c0ddff96bbdd46937f64122b8c925cab503dd37f8214/pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629", size = 83135, upload-time = "2024-09-11T16:00:36.122Z" },
-]
-
 [[package]]
 name = "pycparser"
 version = "2.23"
@@ -799,25 +776,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5f/ed/539768cf28c661b5b068d66d96a2f155c4971a5d55684a514c1a0e0dec2f/python_dotenv-1.1.1-py3-none-any.whl", hash = "sha256:31f23644fe2602f88ff55e1f5c79ba497e01224ee7737937930c448e4d0e24dc", size = 20556, upload-time = "2025-06-24T04:21:06.073Z" },
 ]
 
-[[package]]
-name = "python-jose"
-version = "3.5.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "ecdsa" },
-    { name = "pyasn1" },
-    { name = "rsa" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/c6/77/3a1c9039db7124eb039772b935f2244fbb73fc8ee65b9acf2375da1c07bf/python_jose-3.5.0.tar.gz", hash = "sha256:fb4eaa44dbeb1c26dcc69e4bd7ec54a1cb8dd64d3b4d81ef08d90ff453f2b01b", size = 92726, upload-time = "2025-05-28T17:31:54.288Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d9/c3/0bd11992072e6a1c513b16500a5d07f91a24017c5909b02c72c62d7ad024/python_jose-3.5.0-py2.py3-none-any.whl", hash = "sha256:abd1202f23d34dfad2c3d28cb8617b90acf34132c7afd60abd0b0b7d3cb55771", size = 34624, upload-time = "2025-05-28T17:31:52.802Z" },
-]
-
-[package.optional-dependencies]
-cryptography = [
-    { name = "cryptography" },
-]
-
 [[package]]
 name = "python-multipart"
 version = "0.0.20"
@@ -885,18 +843,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d2/07/a5c7aef12f9a3497f5ad77157a37915645861e8b23b89b2ad4b0f11b48ad/realtime-2.7.0-py3-none-any.whl", hash = "sha256:d55a278803529a69d61c7174f16563a9cfa5bacc1664f656959694481903d99c", size = 22409, upload-time = "2025-07-28T18:54:21.383Z" },
 ]
 
-[[package]]
-name = "rsa"
-version = "4.9.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pyasn1" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/da/8a/22b7beea3ee0d44b1916c0c1cb0ee3af23b700b6da9f04991899d0c555d4/rsa-4.9.1.tar.gz", hash = "sha256:e7bdbfdb5497da4c07dfd35530e1a902659db6ff241e39d9953cad06ebd0ae75", size = 29034, upload-time = "2025-04-16T09:51:18.218Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/64/8d/0133e4eb4beed9e425d9a98ed6e081a55d195481b7632472be1af08d2f6b/rsa-4.9.1-py3-none-any.whl", hash = "sha256:68635866661c6836b8d39430f97a996acbd61bfa49406748ea243539fe239762", size = 34696, upload-time = "2025-04-16T09:51:17.142Z" },
-]
-
 [[package]]
 name = "ruff"
 version = "0.13.0"

langchain_trigger_server-0.3.6/version_comparison.txt

@@ -0,0 +1 @@
+Current: 0.3.6, PyPI: 0.3.5, Should publish: True

langchain_trigger_server-0.3.4/langchain_triggers/database/__init__.py

@@ -1,16 +0,0 @@
-"""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"]

langchain_trigger_server-0.3.4/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

langchain_trigger_server-0.3.4/version_comparison.txt

@@ -1 +0,0 @@
-Current: 0.3.4, PyPI: 0.3.3, Should publish: True