langchain-trigger-server 0.3.7__tar.gz → 0.3.9__tar.gz

{langchain_trigger_server-0.3.7 → langchain_trigger_server-0.3.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-trigger-server
-Version: 0.3.7
+Version: 0.3.9
 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.7 → langchain_trigger_server-0.3.9}/langchain_triggers/app.py

@@ -157,7 +157,6 @@ class TriggerServer:
         # Add startup and shutdown events
         @self.app.on_event("startup")
         async def startup_event():
-            await self.ensure_trigger_templates()
             await self.cron_manager.start()
 
         @self.app.on_event("shutdown")
@@ -210,29 +209,6 @@ class TriggerServer:
             f"Registered trigger template in memory: {trigger.name} ({trigger.id})"
         )
 
-    async def ensure_trigger_templates(self) -> None:
-        """Ensure all registered trigger templates exist in the database."""
-        for trigger in self.triggers:
-            existing = await self.database.get_trigger_template(trigger.id)
-            if not existing:
-                logger.info(
-                    f"Creating new trigger template in database: {trigger.name} ({trigger.id})"
-                )
-                await self.database.create_trigger_template(
-                    id=trigger.id,
-                    provider=trigger.provider,
-                    name=trigger.name,
-                    description=trigger.description,
-                    registration_schema=trigger.registration_model.model_json_schema(),
-                )
-                logger.info(
-                    f"✓ Successfully created trigger template: {trigger.name} ({trigger.id})"
-                )
-            else:
-                logger.info(
-                    f"✓ Trigger template already exists in database: {trigger.name} ({trigger.id})"
-                )
-
     def add_triggers(self, triggers: list[TriggerTemplate]) -> None:
         """Add multiple triggers."""
         for trigger in triggers:
@@ -251,19 +227,20 @@ class TriggerServer:
 
         @self.app.get("/v1/triggers")
         async def api_list_triggers() -> dict[str, Any]:
-            """List available trigger templates."""
-            templates = await self.database.get_trigger_templates()
+            """List available trigger templates from in-memory registry."""
             trigger_list = []
-            for template in templates:
+            for trigger in self.triggers:
                 trigger_list.append(
                     {
-                        "id": template["id"],
-                        "provider": template["provider"],
-                        "displayName": template["name"],
-                        "description": template["description"],
+                        "id": trigger.id,
+                        "provider": trigger.provider,
+                        "displayName": trigger.name,
+                        "description": trigger.description,
                         "path": "/v1/triggers/registrations",
                         "method": "POST",
-                        "payloadSchema": template.get("registration_schema", {}),
+                        "payloadSchema": trigger.registration_model.model_json_schema(),
+                        "display_name": trigger.display_name,
+                        "integration": trigger.integration,
                     }
                 )
 
@@ -292,7 +269,7 @@ class TriggerServer:
                         {
                             "id": reg["id"],
                             "user_id": reg["user_id"],
-                            "template_id": reg.get("trigger_templates", {}).get("id"),
+                            "template_id": reg.get("template_id"),
                             "resource": reg["resource"],
                             "linked_agent_ids": reg.get("linked_agent_ids", []),
                             "created_at": reg["created_at"],

{langchain_trigger_server-0.3.7 → langchain_trigger_server-0.3.9}/langchain_triggers/database/interface.py

@@ -7,30 +7,6 @@ from typing import Any
 class TriggerDatabaseInterface(ABC):
     """Abstract interface for trigger database operations."""
 
-    # ========== Trigger Templates ==========
-
-    @abstractmethod
-    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."""
-        pass
-
-    @abstractmethod
-    async def get_trigger_templates(self) -> list[dict[str, Any]]:
-        """Get all available trigger templates."""
-        pass
-
-    @abstractmethod
-    async def get_trigger_template(self, id: str) -> dict[str, Any] | None:
-        """Get a specific trigger template by ID."""
-        pass
-
     # ========== Trigger Registrations ==========
 
     @abstractmethod

{langchain_trigger_server-0.3.7 → langchain_trigger_server-0.3.9}/langchain_triggers/decorators.py

@@ -31,7 +31,25 @@ class TriggerTemplate:
         trigger_type: TriggerType = TriggerType.WEBHOOK,
         poll_handler: Any | None = None,
         default_crontab: str | None = None,
+        display_name: str | None = None,
+        integration: str | None = None,
     ):
+        """Initialize a trigger template.
+
+        Args:
+            id: Unique identifier for the trigger
+            provider: (DEPRECATED: use display_name) Display name for grouping in UI
+            name: Human-readable name for the trigger
+            description: Description of what the trigger does
+            registration_model: Pydantic model for registration data
+            registration_handler: Async function to handle registration
+            trigger_handler: Async function to handle webhook events (for webhook triggers)
+            trigger_type: Type of trigger (webhook or polling)
+            poll_handler: Async function to handle polling (for polling triggers)
+            default_crontab: Default cron schedule for polling triggers
+            display_name: Display name for grouping triggers (e.g., "Slack", "Gmail")
+            integration: Integration ID for logo mapping (e.g., "slack", "gmail")
+        """
         self.id = id
         self.provider = provider
         self.name = name
@@ -42,6 +60,8 @@ class TriggerTemplate:
         self.trigger_type = trigger_type
         self.poll_handler = poll_handler
         self.default_crontab = default_crontab
+        self.display_name = display_name
+        self.integration = integration
 
         self._validate_handler_signatures()
 

{langchain_trigger_server-0.3.7 → langchain_trigger_server-0.3.9}/langchain_triggers/triggers/cron_trigger.py

@@ -1,6 +1,7 @@
 """Cron-based trigger for scheduled agent execution."""
 
 import logging
+import uuid
 from datetime import datetime
 from typing import Any
 
@@ -85,11 +86,14 @@ async def cron_poll_handler(
     tenant_id = str(registration.get("tenant_id", ""))
 
     agent_links = await database.get_agents_for_trigger(registration_id)
+
     if not agent_links:
         logger.info(f"cron_no_linked_agents registration_id={registration_id}")
         return {"success": True, "message": "No linked agents", "agents_invoked": 0}
 
-    client = get_client(url=get_langgraph_url(), api_key=None)
+    langgraph_url = get_langgraph_url()
+
+    client = get_client(url=langgraph_url, api_key=None)
     headers = create_service_auth_headers(user_id, tenant_id)
 
     current_time = datetime.utcnow()
@@ -100,9 +104,29 @@ async def cron_poll_handler(
         agent_id = str(
             agent_link if isinstance(agent_link, str) else agent_link.get("agent_id")
         )
+
         try:
+            thread_id = str(uuid.uuid4())
+
+            try:
+                await client.threads.create(
+                    thread_id=thread_id,
+                    if_exists="do_nothing",
+                    metadata={
+                        "triggered_by": "cron-trigger",
+                        "user_id": user_id,
+                        "tenant_id": tenant_id,
+                        "registration_id": str(registration_id),
+                    },
+                    headers=headers,
+                )
+            except Exception as thread_err:
+                logger.warning(
+                    f"cron_thread_create_failed thread_id={thread_id} error={str(thread_err)}"
+                )
+
             await client.runs.create(
-                None,
+                thread_id,
                 agent_id,
                 input={
                     "messages": [
@@ -115,7 +139,7 @@ async def cron_poll_handler(
                 headers=headers,
             )
             logger.info(
-                f"cron_run_ok registration_id={registration_id} agent_id={agent_id}"
+                f"cron_run_ok registration_id={registration_id} agent_id={agent_id} thread_id={thread_id}"
             )
             agents_invoked += 1
         except Exception as e:
@@ -135,4 +159,6 @@ cron_trigger = TriggerTemplate(
     registration_handler=cron_registration_handler,
     trigger_type=TriggerType.POLLING,
     poll_handler=cron_poll_handler,
+    display_name="Cron",
+    integration=None,
 )

{langchain_trigger_server-0.3.7 → langchain_trigger_server-0.3.9}/pyproject.toml

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

{langchain_trigger_server-0.3.7 → langchain_trigger_server-0.3.9}/tests/unit/test_trigger_server_api.py

@@ -40,29 +40,9 @@ class MockDatabase:
     """Mock database for testing."""
 
     def __init__(self):
-        self.templates = []
         self.registrations = []
         self.agent_links = []
 
-    async def create_trigger_template(
-        self, id, provider, name, description, registration_schema
-    ):
-        template = {
-            "id": id,
-            "provider": provider,
-            "name": name,
-            "description": description,
-            "registration_schema": registration_schema,
-        }
-        self.templates.append(template)
-        return template
-
-    async def get_trigger_template(self, id):
-        return next((t for t in self.templates if t["id"] == id), None)
-
-    async def get_trigger_templates(self):
-        return self.templates
-
     async def create_trigger_registration(
         self, user_id, tenant_id, template_id, resource, metadata
     ):
@@ -83,7 +63,6 @@ class MockDatabase:
         return [
             {
                 **reg,
-                "trigger_templates": {"id": reg["template_id"]},
                 "linked_agent_ids": reg.get("linked_agent_ids", []),
             }
             for reg in self.registrations
@@ -233,15 +212,27 @@ async def test_health_endpoint(trigger_server):
 
 @pytest.mark.asyncio
 async def test_list_triggers_endpoint(trigger_server):
-    """Test listing trigger templates."""
-    # Add a trigger template to the mock database
-    await trigger_server.database.create_trigger_template(
+    """Test listing trigger templates from in-memory registry."""
+    from langchain_triggers import (
+        TriggerRegistrationResult,
+        TriggerTemplate,
+    )
+
+    # Create a test trigger registration handler
+    async def test_registration_handler(request, user_id, registration):
+        return TriggerRegistrationResult()
+
+    # Add a trigger template to the in-memory registry
+    test_trigger = TriggerTemplate(
         id="test_trigger",
         provider="test",
         name="Test Trigger",
         description="A test trigger",
-        registration_schema={"type": "object"},
+        registration_model=TestRegistration,
+        registration_handler=test_registration_handler,
+        trigger_handler=dummy_trigger_handler,
     )
+    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:

{langchain_trigger_server-0.3.7 → langchain_trigger_server-0.3.9}/uv.lock

@@ -381,7 +381,7 @@ wheels = [
 
 [[package]]
 name = "langchain-trigger-server"
-version = "0.3.7"
+version = "0.3.9"
 source = { editable = "." }
 dependencies = [
     { name = "apscheduler" },

langchain_trigger_server-0.3.9/version_comparison.txt

@@ -0,0 +1 @@
+Current: 0.3.9, PyPI: 0.3.8, Should publish: True

langchain_trigger_server-0.3.7/version_comparison.txt

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