langchain-trigger-server 0.3__tar.gz → 0.3.2__tar.gz

{langchain_trigger_server-0.3 → langchain_trigger_server-0.3.2}/PKG-INFO

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

@@ -21,10 +21,10 @@ from .auth.slack_hmac import (
     get_slack_signing_secret,
     verify_slack_signature,
 )
+from .core import TriggerType
 from .cron_manager import CronTriggerManager
 from .database import TriggerDatabaseInterface, create_database
 from .decorators import TriggerTemplate
-from .triggers.cron_trigger import CRON_TRIGGER_ID
 
 logger = logging.getLogger(__name__)
 
@@ -419,6 +419,29 @@ class TriggerServer:
                 logger.exception(f"Error creating trigger registration: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
 
+        @self.app.delete("/v1/triggers/registrations/{registration_id}")
+        async def api_delete_registration(
+            registration_id: str,
+            current_user: dict[str, Any] = Depends(get_current_user),
+        ) -> dict[str, Any]:
+            """Delete a trigger registration."""
+            try:
+                user_id = current_user["identity"]
+                success = await self.database.delete_trigger_registration(
+                    registration_id, user_id
+                )
+                if not success:
+                    raise HTTPException(
+                        status_code=500, detail="Failed to delete trigger registration"
+                    )
+                return {"success": True}
+
+            except HTTPException:
+                raise
+            except Exception as e:
+                logger.error(f"Error deleting trigger registration: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+
         @self.app.get("/v1/triggers/registrations/{registration_id}/agents")
         async def api_list_registration_agents(
             registration_id: str,
@@ -566,12 +589,34 @@ class TriggerServer:
                         detail="Trigger registration not found or access denied",
                     )
 
-                # Get the template to check if it's a cron trigger
+                # Get the template to check if it's a polling trigger
                 template_id = registration.get("template_id")
-                if template_id != CRON_TRIGGER_ID:
+                tmpl = (
+                    next((t for t in self.triggers if t.id == template_id), None)
+                    if template_id
+                    else None
+                )
+                if not template_id or not tmpl:
+                    error_reason = (
+                        "missing_template_id"
+                        if not template_id
+                        else "template_not_found"
+                    )
+                    logger.error(
+                        "manual_execute_error registration_id=%s template_id=%s error=%s",
+                        registration_id,
+                        template_id,
+                        error_reason,
+                        stack_info=True,
+                    )
+                    raise HTTPException(status_code=500, detail="Internal server error")
+                if (
+                    getattr(tmpl.trigger_type, "value", tmpl.trigger_type)
+                    != TriggerType.POLLING.value
+                ):
                     raise HTTPException(
                         status_code=400,
-                        detail="Manual execution is only supported for cron triggers",
+                        detail="Manual execution is only supported for polling triggers",
                     )
 
                 # Execute the cron trigger using the cron manager

{langchain_trigger_server-0.3 → langchain_trigger_server-0.3.2}/langchain_triggers/core.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from enum import Enum
 from typing import Any
 
 from pydantic import BaseModel, Field
@@ -10,6 +11,13 @@ from pydantic import BaseModel, Field
 logger = logging.getLogger(__name__)
 
 
+class TriggerType(str, Enum):
+    """Type of trigger supported by the framework."""
+
+    WEBHOOK = "webhook"
+    POLLING = "polling"
+
+
 class ProviderAuthInfo(BaseModel):
     """Authentication info for a specific OAuth provider."""
 

langchain_trigger_server-0.3.2/langchain_triggers/cron_manager.py

@@ -0,0 +1,418 @@
+"""Dynamic Cron Trigger Manager for scheduled agent execution."""
+
+import logging
+from datetime import datetime
+from typing import Any
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger as APSCronTrigger
+from pydantic import BaseModel
+
+from langchain_triggers.core import TriggerHandlerResult, TriggerType
+
+logger = logging.getLogger(__name__)
+
+
+class CronJobExecution(BaseModel):
+    """Model for tracking cron job execution history."""
+
+    registration_id: str
+    cron_pattern: str
+    scheduled_time: datetime
+    actual_start_time: datetime
+    completion_time: datetime | None = None
+    status: str  # "running", "completed", "failed"
+    error_message: str | None = None
+    agents_invoked: int = 0
+
+
+class CronTriggerManager:
+    """Manages dynamic cron job scheduling based on database registrations."""
+
+    def __init__(self, trigger_server):
+        self.scheduler = AsyncIOScheduler(timezone="UTC")
+        self.trigger_server = trigger_server
+        self.active_jobs = {}  # registration_id -> job_id mapping
+        self.execution_history = []  # Keep recent execution history
+        self.max_history = 1000
+
+    def _is_polling(self, trigger) -> bool:
+        ttype = getattr(trigger, "trigger_type", None)
+        val = getattr(ttype, "value", ttype)
+        try:
+            return str(val).lower() == TriggerType.POLLING.value
+        except Exception:
+            return False
+
+    async def start(self):
+        """Start scheduler and load existing cron registrations."""
+        try:
+            self.scheduler.start()
+            logger.info("polling_manager_started timezone=UTC")
+            await self._load_existing_registrations()
+        except Exception as e:
+            logger.error(f"Failed to start CronTriggerManager: {e}")
+            raise
+
+    async def shutdown(self):
+        """Shutdown scheduler gracefully."""
+        try:
+            self.scheduler.shutdown(wait=True)
+        except Exception as e:
+            logger.error(f"Error shutting down CronTriggerManager: {e}")
+
+    async def _load_existing_registrations(self):
+        """Load all existing polling registrations from database and schedule them.
+
+        Discovers polling-capable triggers dynamically from registered templates.
+        """
+        try:
+            scheduled_total = 0
+            polling_templates = [
+                t for t in self.trigger_server.triggers if self._is_polling(t)
+            ]
+            ids_csv = ",".join([t.id for t in polling_templates]) or ""
+            logger.info(
+                f"polling_templates_loaded count={len(polling_templates)} ids={ids_csv}"
+            )
+
+            for template in polling_templates:
+                template_id = template.id
+                logger.info(
+                    "polling_template "
+                    f"template_id={template_id} provider={(template.provider or '').lower()} name={getattr(template, 'name', '')}"
+                )
+                try:
+                    registrations = (
+                        await self.trigger_server.database.get_all_registrations(
+                            template_id
+                        )
+                    )
+                    logger.info(
+                        f"registrations_fetched template_id={template_id} count={len(registrations)}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"registrations_fetch_err template_id={template_id} error={str(e)}"
+                    )
+                    continue
+
+                scheduled_for_template = 0
+                for registration in registrations:
+                    if registration.get("status") == "active":
+                        try:
+                            await self._schedule_cron_job(registration)
+                            scheduled_total += 1
+                            scheduled_for_template += 1
+                        except Exception as e:
+                            logger.error(
+                                "registration_schedule_err "
+                                f"registration_id={registration.get('id')} template_id={template_id} error={str(e)}"
+                            )
+                logger.debug(
+                    f"registrations_scheduled template_id={template_id} scheduled={scheduled_for_template}"
+                )
+            logger.debug(f"polling_schedule_complete total_scheduled={scheduled_total}")
+        except Exception as e:
+            logger.error(f"polling_load_err error={str(e)}")
+
+    async def reload_from_database(self):
+        """Reload all cron registrations from database, replacing current schedules."""
+        try:
+            # Clear all current jobs
+            for registration_id in list(self.active_jobs.keys()):
+                await self._unschedule_cron_job(registration_id)
+
+            # Reload from database
+            await self._load_existing_registrations()
+
+        except Exception as e:
+            logger.error(f"Failed to reload cron jobs from database: {e}")
+            raise
+
+    async def on_registration_created(self, registration: dict[str, Any]):
+        """Called when a new polling registration is created."""
+        template_id_raw = registration.get("template_id")
+        template_id = str(template_id_raw) if template_id_raw is not None else None
+        if template_id is None:
+            logger.error(
+                "registration_missing_template_id id=%s", registration.get("id")
+            )
+            return
+        tmpl = next(
+            (t for t in self.trigger_server.triggers if t.id == template_id), None
+        )
+        if not tmpl:
+            logger.error(
+                "registration_template_not_found id=%s template_id=%s",
+                registration.get("id"),
+                template_id,
+            )
+            return
+        if self._is_polling(tmpl):
+            try:
+                await self._schedule_cron_job(registration)
+            except Exception as e:
+                logger.error(
+                    f"Failed to schedule new cron job {registration.get('id')}: {e}"
+                )
+                raise
+        else:
+            logger.debug(
+                "registration_not_polling id=%s template_id=%s trigger_type=%s",
+                registration.get("id"),
+                template_id,
+                tmpl.trigger_type,
+            )
+
+    async def on_registration_deleted(self, registration_id: str):
+        """Called when a cron registration is deleted."""
+        try:
+            await self._unschedule_cron_job(registration_id)
+        except Exception as e:
+            logger.error(f"Failed to unschedule cron job {registration_id}: {e}")
+
+    async def _schedule_cron_job(self, registration: dict[str, Any]):
+        """Add a polling job to the scheduler using a 5-field crontab."""
+        registration_id = registration["id"]
+        resource_data = registration.get("resource", {})
+        crontab = (resource_data.get("crontab") or "").strip()
+        template_id = registration.get("template_id")
+        template_id = str(template_id) if template_id is not None else None
+        tmpl = next(
+            (t for t in self.trigger_server.triggers if t.id == template_id), None
+        )
+        if tmpl and not crontab:
+            crontab = (getattr(tmpl, "default_crontab", None) or "").strip()
+
+        try:
+            if not crontab:
+                if template_id is None:
+                    raise ValueError(
+                        f"No schedule provided for registration {registration_id} (missing template_id)"
+                    )
+                if tmpl is None:
+                    raise ValueError(
+                        f"No schedule provided for registration {registration_id} (template '{template_id}' not found)"
+                    )
+                raise ValueError(
+                    f"No schedule provided for registration {registration_id} (no crontab and no default_crontab for template '{template_id}')"
+                )
+
+            cron_parts = crontab.split()
+            if len(cron_parts) != 5:
+                raise ValueError(f"Invalid cron format: {crontab} (expected 5 parts)")
+            minute, hour, day, month, day_of_week = cron_parts
+            trigger = APSCronTrigger(
+                minute=minute,
+                hour=hour,
+                day=day,
+                month=month,
+                day_of_week=day_of_week,
+                timezone="UTC",
+            )
+            job_id = f"cron_{registration_id}"
+            logger.info(
+                f"schedule_cron registration_id={registration_id} crontab='{crontab}' job_id={job_id}"
+            )
+
+            job = self.scheduler.add_job(
+                self._execute_cron_job_with_monitoring,
+                trigger=trigger,
+                args=[registration],
+                id=job_id,
+                name=f"Polling job for registration {registration_id}",
+                max_instances=1,
+                replace_existing=True,
+            )
+
+            self.active_jobs[registration_id] = job.id
+
+        except Exception as e:
+            logger.error(
+                f"Failed to schedule polling job for registration {registration_id}: {e}"
+            )
+            raise
+
+    async def _unschedule_cron_job(self, registration_id: str):
+        """Remove a cron job from the scheduler."""
+        if registration_id in self.active_jobs:
+            job_id = self.active_jobs[registration_id]
+            try:
+                self.scheduler.remove_job(job_id)
+                del self.active_jobs[registration_id]
+            except Exception as e:
+                logger.error(f"Failed to unschedule cron job {job_id}: {e}")
+                raise
+        else:
+            logger.warning(
+                f"Attempted to unschedule non-existent cron job {registration_id}"
+            )
+
+    async def _execute_cron_job_with_monitoring(self, registration: dict[str, Any]):
+        """Execute a scheduled cron job with full monitoring and error handling."""
+        registration_id = registration["id"]
+        cron_pattern = registration["resource"]["crontab"]
+
+        execution = CronJobExecution(
+            registration_id=str(registration_id),
+            cron_pattern=cron_pattern,
+            scheduled_time=datetime.utcnow(),
+            actual_start_time=datetime.utcnow(),
+            status="running",
+        )
+
+        try:
+            agents_invoked = await self.execute_cron_job(registration)
+            execution.status = "completed"
+            execution.agents_invoked = agents_invoked
+            logger.info(
+                f"✓ Cron job {registration_id} completed successfully - invoked {agents_invoked} agent(s)"
+            )
+
+        except Exception as e:
+            execution.status = "failed"
+            execution.error_message = str(e)
+            logger.error(f"✗ Cron job {registration_id} failed: {e}")
+
+        finally:
+            execution.completion_time = datetime.utcnow()
+            await self._record_execution(execution)
+
+    async def execute_cron_job(self, registration: dict[str, Any]) -> int:
+        """Execute a cron job - invoke agents. Can be called manually or by scheduler."""
+        registration_id = registration["id"]
+        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")
+        )
+
+        # Get agent links
+        agent_links = await self.trigger_server.database.get_agents_for_trigger(
+            registration_id
+        )
+
+        if not agent_links:
+            logger.warning(f"No agents linked to cron job {registration_id}")
+            return 0
+
+        tmpl = next(
+            (t for t in self.trigger_server.triggers if t.id == template_id), None
+        )
+
+        if not tmpl or not self._is_polling(tmpl):
+            available_ids = ",".join([t.id for t in self.trigger_server.triggers])
+            logger.error(
+                "template_not_polling "
+                f"template_id={template_id} available_templates={available_ids}"
+            )
+            return 0
+
+        result: TriggerHandlerResult = await tmpl.poll_handler(
+            registration,
+            self.trigger_server.database,
+            self.trigger_server.langchain_auth_client,
+        )
+
+        if not result.invoke_agent:
+            logger.info(
+                "poll_result "
+                f"registration_id={registration_id} "
+                f"trigger_id={template_id} "
+                f"provider={(tmpl.provider or '').lower()} "
+                f"invoke_agent=false messages_count=0"
+            )
+            return 0
+
+        agents_invoked = 0
+        messages = result.agent_messages or []
+
+        logger.info(
+            "poll_result "
+            f"registration_id={registration_id} "
+            f"trigger_id={template_id} "
+            f"provider={(tmpl.provider or '').lower()} "
+            f"invoke_agent=true messages_count={len(messages)} "
+            f"agents_linked={len(agent_links)}"
+        )
+
+        for message in messages:
+            for agent_link in agent_links:
+                agent_id = (
+                    agent_link
+                    if isinstance(agent_link, str)
+                    else agent_link.get("agent_id")
+                )
+                # Ensure agent_id and user_id are strings for JSON serialization
+                agent_id_str = str(agent_id)
+                user_id_str = str(user_id)
+                tenant_id_str = str(tenant_id)
+
+                current_time = datetime.utcnow()
+                current_time_str = current_time.strftime("%A, %B %d, %Y at %H:%M UTC")
+
+                agent_input = {
+                    "messages": [
+                        {
+                            "role": "human",
+                            "content": f"ACTION: triggering cron from langchain-trigger-server\nCURRENT TIME: {current_time_str}\n\n{message}",
+                        }
+                    ]
+                }
+
+                try:
+                    success = await self.trigger_server._invoke_agent(
+                        agent_id=agent_id_str,
+                        user_id=user_id_str,
+                        tenant_id=tenant_id_str,
+                        input_data=agent_input,
+                    )
+                    if success:
+                        logger.info(
+                            "invoke_agent_ok "
+                            f"registration_id={registration_id} "
+                            f"agent_id={agent_id_str}"
+                        )
+                        agents_invoked += 1
+                except Exception as e:
+                    logger.error(
+                        "invoke_agent_err "
+                        f"registration_id={registration_id} "
+                        f"agent_id={agent_id_str} "
+                        f"error={str(e)}"
+                    )
+
+        logger.info(
+            "poll_invoke_summary "
+            f"registration_id={registration_id} "
+            f"agents_invoked={agents_invoked} "
+            f"messages_count={len(messages)}"
+        )
+        return agents_invoked
+
+    async def _record_execution(self, execution: CronJobExecution):
+        """Record execution history (in memory for now)."""
+        self.execution_history.append(execution)
+
+        # Keep only recent executions
+        if len(self.execution_history) > self.max_history:
+            self.execution_history = self.execution_history[-self.max_history :]
+
+    def get_active_jobs(self) -> dict[str, str]:
+        """Get currently active cron jobs."""
+        return self.active_jobs.copy()
+
+    def get_execution_history(self, limit: int = 100) -> list[CronJobExecution]:
+        """Get recent execution history."""
+        return self.execution_history[-limit:]
+
+    def get_job_status(self) -> dict[str, Any]:
+        """Get status information about the cron manager."""
+        return {
+            "active_jobs": len(self.active_jobs),
+            "scheduler_running": self.scheduler.running,
+            "total_executions": len(self.execution_history),
+            "active_job_ids": list(self.active_jobs.keys()),
+        }

{langchain_trigger_server-0.3 → langchain_trigger_server-0.3.2}/langchain_triggers/decorators.py

@@ -1,4 +1,8 @@
-"""Trigger system - templates with registration and webhook handlers."""
+"""Trigger system - templates with registration and webhook handlers.
+
+Also supports polling triggers (no HTTP route) via a `poll_handler` that the
+framework scheduler can call on a cadence.
+"""
 
 from __future__ import annotations
 
@@ -8,7 +12,7 @@ from typing import Any, get_type_hints
 from langchain_auth.client import Client
 from pydantic import BaseModel
 
-from .core import TriggerHandlerResult, TriggerRegistrationResult
+from .core import TriggerHandlerResult, TriggerRegistrationResult, TriggerType
 
 
 class TriggerTemplate:
@@ -22,7 +26,11 @@ class TriggerTemplate:
         description: str,
         registration_model: type[BaseModel],
         registration_handler,
-        trigger_handler,
+        trigger_handler=None,
+        *,
+        trigger_type: TriggerType = TriggerType.WEBHOOK,
+        poll_handler: Any | None = None,
+        default_crontab: str | None = None,
     ):
         self.id = id
         self.provider = provider
@@ -31,12 +39,15 @@ class TriggerTemplate:
         self.registration_model = registration_model
         self.registration_handler = registration_handler
         self.trigger_handler = trigger_handler
+        self.trigger_type = trigger_type
+        self.poll_handler = poll_handler
+        self.default_crontab = default_crontab
 
         self._validate_handler_signatures()
 
     def _validate_handler_signatures(self):
         """Validate that all handler functions have the correct signatures."""
-        # Expected: async def handler(user_id: str, auth_client: Client, registration: RegistrationModel) -> TriggerRegistrationResult
+        # Expected reg: async def handler(user_id: str, auth_client: Client, registration: RegistrationModel) -> TriggerRegistrationResult
         self._validate_handler(
             "registration_handler",
             self.registration_handler,
@@ -44,13 +55,28 @@ class TriggerTemplate:
             TriggerRegistrationResult,
         )
 
-        # Expected: async def handler(payload: Dict[str, Any], query_params: Dict[str, str], database, auth_client: Client) -> TriggerHandlerResult
-        self._validate_handler(
-            "trigger_handler",
-            self.trigger_handler,
-            [dict[str, Any], dict[str, str], Any, Client],
-            TriggerHandlerResult,
-        )
+        if self.trigger_type == TriggerType.WEBHOOK:
+            if not self.trigger_handler:
+                raise TypeError(
+                    f"trigger_handler required for webhook trigger '{self.id}'"
+                )
+            self._validate_handler(
+                "trigger_handler",
+                self.trigger_handler,
+                [dict[str, Any], dict[str, str], Any, Client],
+                TriggerHandlerResult,
+            )
+        else:
+            if not self.poll_handler:
+                raise TypeError(
+                    f"poll_handler required for polling trigger '{self.id}'"
+                )
+            self._validate_handler(
+                "poll_handler",
+                self.poll_handler,
+                [dict[str, Any], Any, Client],
+                TriggerHandlerResult,
+            )
 
     def _validate_handler(
         self,

{langchain_trigger_server-0.3 → langchain_trigger_server-0.3.2}/langchain_triggers/triggers/cron_trigger.py

@@ -12,6 +12,7 @@ from langchain_triggers.core import (
     TriggerHandlerResult,
     TriggerRegistrationModel,
     TriggerRegistrationResult,
+    TriggerType,
 )
 from langchain_triggers.decorators import TriggerTemplate
 
@@ -73,20 +74,25 @@ async def cron_registration_handler(
     )
 
 
-async def cron_trigger_handler(
-    payload: dict[str, Any],
-    query_params: dict[str, str],
+async def cron_poll_handler(
+    registration: dict[str, Any],
     database,
     auth_client: Client,
 ) -> TriggerHandlerResult:
-    """Cron trigger handler - this should never be called via HTTP."""
-    logger.warning("Cron trigger handler called via HTTP - this shouldn't happen")
+    """Polling handler for generic cron.
+
+    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}"
+    )
     return TriggerHandlerResult(
-        invoke_agent=False,
-        response_body={
-            "success": False,
-            "message": "Cron triggers are executed by scheduler, not HTTP requests",
-        },
+        invoke_agent=True,
+        agent_messages=[message],
+        registration=registration,
     )
 
 
@@ -97,5 +103,6 @@ cron_trigger = TriggerTemplate(
     description="Triggers agents on a cron schedule",
     registration_model=CronRegistration,
     registration_handler=cron_registration_handler,
-    trigger_handler=cron_trigger_handler,
+    trigger_type=TriggerType.POLLING,
+    poll_handler=cron_poll_handler,
 )

{langchain_trigger_server-0.3 → langchain_trigger_server-0.3.2}/pyproject.toml

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

langchain_trigger_server-0.3.2/tests/unit/test_cron_manager_polling_filter.py

@@ -0,0 +1,136 @@
+"""Unit tests for CronTriggerManager filtering logic (polling vs webhook)."""
+
+from unittest.mock import AsyncMock
+
+import pytest
+from pydantic import BaseModel
+
+from langchain_triggers.core import TriggerType
+from langchain_triggers.cron_manager import CronTriggerManager
+from langchain_triggers.decorators import TriggerTemplate
+from langchain_triggers.triggers import cron_trigger
+
+
+class _DummyRegModel(BaseModel):
+    field: str | None = None
+
+
+async def _dummy_reg_handler(user_id, auth_client, registration):
+    from langchain_triggers.core import TriggerRegistrationResult
+
+    return TriggerRegistrationResult()
+
+
+async def _dummy_trigger_handler(payload, query_params, database, auth_client):
+    from langchain_triggers.core import TriggerHandlerResult
+
+    return TriggerHandlerResult(invoke_agent=False, response_body={"ok": True})
+
+
+class _FakeDB:
+    def __init__(self, registrations_by_template):
+        self._registrations_by_template = registrations_by_template
+
+    async def get_all_registrations(self, template_id):
+        return self._registrations_by_template.get(template_id, [])
+
+
+class _FakeTriggerServer:
+    def __init__(self, triggers, database):
+        self.triggers = triggers
+        self.database = database
+        self.langchain_auth_client = None
+
+
+@pytest.mark.asyncio
+async def test_load_existing_registrations_only_schedules_polling():
+    webhook_trigger = TriggerTemplate(
+        id="webhook_tmpl",
+        provider="test",
+        name="Webhook",
+        description="webhook",
+        registration_model=_DummyRegModel,
+        registration_handler=_dummy_reg_handler,
+        trigger_handler=_dummy_trigger_handler,
+        trigger_type=TriggerType.WEBHOOK,
+    )
+
+    polling_trigger = cron_trigger
+
+    # Prepare registrations for both templates
+    regs = {
+        webhook_trigger.id: [
+            {
+                "id": "reg_w1",
+                "status": "active",
+                "template_id": webhook_trigger.id,
+                "resource": {},
+            }
+        ],
+        polling_trigger.id: [
+            {
+                "id": "reg_p1",
+                "status": "active",
+                "template_id": polling_trigger.id,
+                "resource": {"crontab": "* * * * *"},
+            },
+            {
+                "id": "reg_p2",
+                "status": "inactive",
+                "template_id": polling_trigger.id,
+                "resource": {"crontab": "* * * * *"},
+            },
+        ],
+    }
+
+    fake_db = _FakeDB(registrations_by_template=regs)
+    fake_server = _FakeTriggerServer(
+        triggers=[webhook_trigger, polling_trigger], database=fake_db
+    )
+    mgr = CronTriggerManager(fake_server)
+
+    mgr._schedule_cron_job = AsyncMock()
+
+    await mgr._load_existing_registrations()
+
+    assert mgr._schedule_cron_job.await_count == 1
+    called_with = mgr._schedule_cron_job.await_args.args[0]
+    assert called_with["id"] == "reg_p1"
+
+
+@pytest.mark.asyncio
+async def test_on_registration_created_only_for_polling():
+    """on_registration_created should call schedule only for polling templates."""
+    webhook_trigger = TriggerTemplate(
+        id="webhook_tmpl2",
+        provider="test",
+        name="Webhook2",
+        description="webhook",
+        registration_model=_DummyRegModel,
+        registration_handler=_dummy_reg_handler,
+        trigger_handler=_dummy_trigger_handler,
+        trigger_type=TriggerType.WEBHOOK,
+    )
+
+    polling_trigger = cron_trigger
+
+    fake_db = _FakeDB(registrations_by_template={})
+    fake_server = _FakeTriggerServer(
+        triggers=[webhook_trigger, polling_trigger], database=fake_db
+    )
+    mgr = CronTriggerManager(fake_server)
+    mgr._schedule_cron_job = AsyncMock()
+
+    await mgr.on_registration_created(
+        {"id": "reg_w2", "template_id": webhook_trigger.id, "resource": {}}
+    )
+    assert mgr._schedule_cron_job.await_count == 0
+
+    await mgr.on_registration_created(
+        {
+            "id": "reg_p3",
+            "template_id": polling_trigger.id,
+            "resource": {"crontab": "* * * * *"},
+        }
+    )
+    assert mgr._schedule_cron_job.await_count == 1

langchain_trigger_server-0.3.2/tests/unit/test_cron_manager_schedule_validation.py

@@ -0,0 +1,48 @@
+"""Validation tests for CronTriggerManager._schedule_cron_job."""
+
+import pytest
+
+from langchain_triggers.cron_manager import CronTriggerManager
+from langchain_triggers.triggers import cron_trigger
+
+
+class _FakeTriggerServer:
+    def __init__(self, triggers):
+        self.triggers = triggers
+        self.database = None
+        self.langchain_auth_client = None
+
+
+@pytest.mark.asyncio
+async def test_schedule_cron_job_requires_crontab():
+    """Missing/empty crontab should raise a clear error."""
+    mgr = CronTriggerManager(_FakeTriggerServer([cron_trigger]))
+
+    registration = {
+        "id": "reg_missing",
+        "template_id": cron_trigger.id,
+        "resource": {},
+    }
+
+    with pytest.raises(ValueError) as exc:
+        await mgr._schedule_cron_job(registration)
+
+    # Message should indicate no schedule was provided
+    assert "No schedule provided" in str(exc.value)
+
+
+@pytest.mark.asyncio
+async def test_schedule_cron_job_rejects_invalid_format():
+    """Invalid crontab (wrong number of fields) should raise."""
+    mgr = CronTriggerManager(_FakeTriggerServer([cron_trigger]))
+
+    registration = {
+        "id": "reg_bad_format",
+        "template_id": cron_trigger.id,
+        "resource": {"crontab": "*"},
+    }
+
+    with pytest.raises(ValueError) as exc:
+        await mgr._schedule_cron_job(registration)
+
+    assert "expected 5 parts" in str(exc.value)

langchain_trigger_server-0.3.2/version_comparison.txt

@@ -0,0 +1 @@
+Current: 0.3.2, PyPI: 0.3, Should publish: True

langchain_trigger_server-0.3/langchain_triggers/cron_manager.py

@@ -1,282 +0,0 @@
-"""Dynamic Cron Trigger Manager for scheduled agent execution."""
-
-import logging
-from datetime import datetime
-from typing import Any
-
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
-from apscheduler.triggers.cron import CronTrigger as APSCronTrigger
-from pydantic import BaseModel
-
-from langchain_triggers.triggers.cron_trigger import CRON_TRIGGER_ID
-
-logger = logging.getLogger(__name__)
-
-
-class CronJobExecution(BaseModel):
-    """Model for tracking cron job execution history."""
-
-    registration_id: str
-    cron_pattern: str
-    scheduled_time: datetime
-    actual_start_time: datetime
-    completion_time: datetime | None = None
-    status: str  # "running", "completed", "failed"
-    error_message: str | None = None
-    agents_invoked: int = 0
-
-
-class CronTriggerManager:
-    """Manages dynamic cron job scheduling based on database registrations."""
-
-    def __init__(self, trigger_server):
-        self.scheduler = AsyncIOScheduler(timezone="UTC")
-        self.trigger_server = trigger_server
-        self.active_jobs = {}  # registration_id -> job_id mapping
-        self.execution_history = []  # Keep recent execution history
-        self.max_history = 1000
-
-    async def start(self):
-        """Start scheduler and load existing cron registrations."""
-        try:
-            self.scheduler.start()
-            await self._load_existing_registrations()
-        except Exception as e:
-            logger.error(f"Failed to start CronTriggerManager: {e}")
-            raise
-
-    async def shutdown(self):
-        """Shutdown scheduler gracefully."""
-        try:
-            self.scheduler.shutdown(wait=True)
-        except Exception as e:
-            logger.error(f"Error shutting down CronTriggerManager: {e}")
-
-    async def _load_existing_registrations(self):
-        """Load all existing cron registrations from database and schedule them."""
-        try:
-            registrations = await self.trigger_server.database.get_all_registrations(
-                CRON_TRIGGER_ID
-            )
-
-            scheduled_count = 0
-            for registration in registrations:
-                if registration.get("status") == "active":
-                    try:
-                        await self._schedule_cron_job(registration)
-                        scheduled_count += 1
-                    except Exception as e:
-                        logger.error(
-                            f"Failed to schedule existing cron job {registration.get('id')}: {e}"
-                        )
-
-        except Exception as e:
-            logger.error(f"Failed to load existing cron registrations: {e}")
-
-    async def reload_from_database(self):
-        """Reload all cron registrations from database, replacing current schedules."""
-        try:
-            # Clear all current jobs
-            for registration_id in list(self.active_jobs.keys()):
-                await self._unschedule_cron_job(registration_id)
-
-            # Reload from database
-            await self._load_existing_registrations()
-
-        except Exception as e:
-            logger.error(f"Failed to reload cron jobs from database: {e}")
-            raise
-
-    async def on_registration_created(self, registration: dict[str, Any]):
-        """Called when a new cron registration is created."""
-        if registration.get("trigger_template_id") == CRON_TRIGGER_ID:
-            try:
-                await self._schedule_cron_job(registration)
-            except Exception as e:
-                logger.error(
-                    f"Failed to schedule new cron job {registration['id']}: {e}"
-                )
-                raise
-
-    async def on_registration_deleted(self, registration_id: str):
-        """Called when a cron registration is deleted."""
-        try:
-            await self._unschedule_cron_job(registration_id)
-        except Exception as e:
-            logger.error(f"Failed to unschedule cron job {registration_id}: {e}")
-
-    async def _schedule_cron_job(self, registration: dict[str, Any]):
-        """Add a cron job to the scheduler."""
-        registration_id = registration["id"]
-        resource_data = registration.get("resource", {})
-        crontab = resource_data.get("crontab", "")
-
-        if not crontab:
-            raise ValueError(
-                f"No crontab pattern found in registration {registration_id}"
-            )
-
-        try:
-            # Parse cron expression
-            cron_parts = crontab.strip().split()
-            if len(cron_parts) != 5:
-                raise ValueError(f"Invalid cron format: {crontab} (expected 5 parts)")
-
-            minute, hour, day, month, day_of_week = cron_parts
-
-            # Create APScheduler cron trigger
-            trigger = APSCronTrigger(
-                minute=minute,
-                hour=hour,
-                day=day,
-                month=month,
-                day_of_week=day_of_week,
-                timezone="UTC",
-            )
-
-            # Schedule the job
-            job = self.scheduler.add_job(
-                self._execute_cron_job_with_monitoring,
-                trigger=trigger,
-                args=[registration],
-                id=f"cron_{registration_id}",
-                name=f"Cron job for registration {registration_id}",
-                max_instances=1,  # Prevent overlapping executions
-                replace_existing=True,
-            )
-
-            self.active_jobs[registration_id] = job.id
-
-        except Exception as e:
-            logger.error(
-                f"Failed to schedule cron job for registration {registration_id}: {e}"
-            )
-            raise
-
-    async def _unschedule_cron_job(self, registration_id: str):
-        """Remove a cron job from the scheduler."""
-        if registration_id in self.active_jobs:
-            job_id = self.active_jobs[registration_id]
-            try:
-                self.scheduler.remove_job(job_id)
-                del self.active_jobs[registration_id]
-            except Exception as e:
-                logger.error(f"Failed to unschedule cron job {job_id}: {e}")
-                raise
-        else:
-            logger.warning(
-                f"Attempted to unschedule non-existent cron job {registration_id}"
-            )
-
-    async def _execute_cron_job_with_monitoring(self, registration: dict[str, Any]):
-        """Execute a scheduled cron job with full monitoring and error handling."""
-        registration_id = registration["id"]
-        cron_pattern = registration["resource"]["crontab"]
-
-        execution = CronJobExecution(
-            registration_id=str(registration_id),
-            cron_pattern=cron_pattern,
-            scheduled_time=datetime.utcnow(),
-            actual_start_time=datetime.utcnow(),
-            status="running",
-        )
-
-        try:
-            agents_invoked = await self.execute_cron_job(registration)
-            execution.status = "completed"
-            execution.agents_invoked = agents_invoked
-            logger.info(
-                f"✓ Cron job {registration_id} completed successfully - invoked {agents_invoked} agent(s)"
-            )
-
-        except Exception as e:
-            execution.status = "failed"
-            execution.error_message = str(e)
-            logger.error(f"✗ Cron job {registration_id} failed: {e}")
-
-        finally:
-            execution.completion_time = datetime.utcnow()
-            await self._record_execution(execution)
-
-    async def execute_cron_job(self, registration: dict[str, Any]) -> int:
-        """Execute a cron job - invoke agents. Can be called manually or by scheduler."""
-        registration_id = registration["id"]
-        user_id = registration["user_id"]
-        tenant_id = (
-            registration.get("metadata", {}).get("client_metadata", {}).get("tenant_id")
-        )
-
-        # Get agent links
-        agent_links = await self.trigger_server.database.get_agents_for_trigger(
-            registration_id
-        )
-
-        if not agent_links:
-            logger.warning(f"No agents linked to cron job {registration_id}")
-            return 0
-
-        agents_invoked = 0
-        for agent_link in agent_links:
-            agent_id = (
-                agent_link
-                if isinstance(agent_link, str)
-                else agent_link.get("agent_id")
-            )
-            # Ensure agent_id and user_id are strings for JSON serialization
-            agent_id_str = str(agent_id)
-            user_id_str = str(user_id)
-            tenant_id_str = str(tenant_id)
-
-            current_time = datetime.utcnow()
-            current_time_str = current_time.strftime("%A, %B %d, %Y at %H:%M UTC")
-
-            agent_input = {
-                "messages": [
-                    {
-                        "role": "human",
-                        "content": f"ACTION: triggering cron from langchain-trigger-server\nCURRENT TIME: {current_time_str}",
-                    }
-                ]
-            }
-
-            try:
-                success = await self.trigger_server._invoke_agent(
-                    agent_id=agent_id_str,
-                    user_id=user_id_str,
-                    tenant_id=tenant_id_str,
-                    input_data=agent_input,
-                )
-                if success:
-                    agents_invoked += 1
-
-            except Exception as e:
-                logger.error(
-                    f"✗ Error invoking agent {agent_id_str} for cron job {registration_id}: {e}"
-                )
-
-        return agents_invoked
-
-    async def _record_execution(self, execution: CronJobExecution):
-        """Record execution history (in memory for now)."""
-        self.execution_history.append(execution)
-
-        # Keep only recent executions
-        if len(self.execution_history) > self.max_history:
-            self.execution_history = self.execution_history[-self.max_history :]
-
-    def get_active_jobs(self) -> dict[str, str]:
-        """Get currently active cron jobs."""
-        return self.active_jobs.copy()
-
-    def get_execution_history(self, limit: int = 100) -> list[CronJobExecution]:
-        """Get recent execution history."""
-        return self.execution_history[-limit:]
-
-    def get_job_status(self) -> dict[str, Any]:
-        """Get status information about the cron manager."""
-        return {
-            "active_jobs": len(self.active_jobs),
-            "scheduler_running": self.scheduler.running,
-            "total_executions": len(self.execution_history),
-            "active_job_ids": list(self.active_jobs.keys()),
-        }

langchain_trigger_server-0.3/version_comparison.txt

@@ -1 +0,0 @@
-Current: 0.3, PyPI: 0.2.10, Should publish: True