langchain-trigger-server 0.1.9__tar.gz → 0.1.10__tar.gz

{langchain_trigger_server-0.1.9 → langchain_trigger_server-0.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-trigger-server
-Version: 0.1.9
+Version: 0.1.10
 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
@@ -16,6 +16,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.9
+Requires-Dist: apscheduler>=3.10.0
+Requires-Dist: croniter>=1.4.0
 Requires-Dist: cryptography>=3.0.0
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: httpx>=0.24.0

{langchain_trigger_server-0.1.9 → langchain_trigger_server-0.1.10}/langchain_triggers/__init__.py

@@ -3,6 +3,7 @@
 from .core import UserAuthInfo, TriggerRegistrationModel, TriggerHandlerResult, TriggerRegistrationResult
 from .decorators import TriggerTemplate
 from .app import TriggerServer
+from .triggers.cron_trigger import cron_trigger
 
 __version__ = "0.1.0"
 
@@ -13,4 +14,5 @@ __all__ = [
     "TriggerRegistrationResult",
     "TriggerTemplate",
     "TriggerServer",
+    "cron_trigger",
 ]

{langchain_trigger_server-0.1.9 → langchain_trigger_server-0.1.10}/langchain_triggers/app.py

@@ -14,6 +14,7 @@ from starlette.responses import Response
 
 from .decorators import TriggerTemplate
 from .database import create_database, TriggerDatabaseInterface
+from .cron_manager import CronTriggerManager
 
 logger = logging.getLogger(__name__)
 
@@ -103,16 +104,24 @@ class TriggerServer:
         
         self.triggers: List[TriggerTemplate] = []
         
+        # Initialize CronTriggerManager
+        self.cron_manager = CronTriggerManager(self)
+        
         # Setup authentication middleware
         self.app.add_middleware(AuthenticationMiddleware, auth_handler=auth_handler)
         
         # Setup routes
         self._setup_routes()
         
-        # Add startup event to ensure trigger templates exist in database
+        # 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")
+        async def shutdown_event():
+            await self.cron_manager.shutdown()
     
     def add_trigger(self, trigger: TriggerTemplate) -> None:
         """Add a trigger template to the app."""
@@ -285,6 +294,9 @@ class TriggerServer:
                 if not registration:
                     raise HTTPException(status_code=500, detail="Failed to create trigger registration")
                 
+                # Reload cron manager to pick up any new cron registrations
+                await self.cron_manager.reload_from_database()
+                
                 # Return registration result
                 return {
                     "success": True,

langchain_trigger_server-0.1.10/langchain_triggers/cron_manager.py

@@ -0,0 +1,259 @@
+"""Dynamic Cron Trigger Manager for scheduled agent execution."""
+
+import logging
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger as APSCronTrigger
+from croniter import croniter
+from pydantic import BaseModel
+
+from langchain_triggers.core import TriggerHandlerResult
+
+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: Optional[datetime] = None
+    status: str  # "running", "completed", "failed"
+    error_message: Optional[str] = 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()
+            logger.info("✓ CronTriggerManager started")
+        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)
+            logger.info("✓ CronTriggerManager stopped")
+        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")
+            
+            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}")
+                        
+            logger.info(f"Loaded {scheduled_count} existing cron registrations from {len(registrations)} total")
+            
+        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()
+            logger.info("✓ Reloaded cron jobs from database")
+            
+        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":
+            try:
+                await self._schedule_cron_job(registration)
+                logger.info(f"Scheduled new cron job for registration {registration['id']}")
+            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)
+            logger.info(f"Unscheduled cron job for deleted registration {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
+            logger.info(f"✓ Scheduled cron job: '{crontab}' for registration {registration_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]
+                logger.info(f"✓ Unscheduled cron job for registration {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=registration_id,
+            cron_pattern=cron_pattern,
+            scheduled_time=datetime.utcnow(),
+            actual_start_time=datetime.utcnow(),
+            status="running"
+        )
+        
+        logger.info(f"🕐 Executing cron job {registration_id} with pattern '{cron_pattern}'")
+        
+        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 - invoked {agents_invoked} agents")
+            
+        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 scheduled cron job - invoke agents."""
+        registration_id = registration["id"]
+        user_id = registration["user_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")
+            
+            agent_input = {
+                "messages": [
+                    {"role": "human", "content": ""}
+                ]
+            }
+            
+            try:
+                success = await self.trigger_server._invoke_agent(
+                    agent_id=agent_id,
+                    user_id=user_id,
+                    input_data=agent_input,
+                )
+                if success:
+                    agents_invoked += 1
+                    logger.info(f"✓ Invoked agent {agent_id} for cron job {registration_id}")
+                    
+            except Exception as e:
+                logger.error(f"✗ Error invoking agent {agent_id} 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.1.9 → langchain_trigger_server-0.1.10}/langchain_triggers/database/supabase.py

@@ -253,7 +253,7 @@ class SupabaseTriggerDatabase(TriggerDatabaseInterface):
         try:
             response = self.client.table("trigger_registrations").select(
                 "*, trigger_templates(id, name, description)"
-            ).eq("trigger_templates.id", template_id).execute()
+            ).eq("template_id", template_id).execute()
             
             return response.data or []
         except Exception as e:

langchain_trigger_server-0.1.10/langchain_triggers/triggers/__init__.py

@@ -0,0 +1,7 @@
+"""Built-in trigger templates for the LangChain Triggers Framework."""
+
+from .cron_trigger import cron_trigger
+
+__all__ = [
+    "cron_trigger",
+]

langchain_trigger_server-0.1.10/langchain_triggers/triggers/cron_trigger.py

@@ -0,0 +1,97 @@
+"""Cron-based trigger for scheduled agent execution."""
+
+import logging
+from datetime import datetime
+from typing import Dict, Any
+
+from croniter import croniter
+from langchain_auth.client import Client
+from pydantic import Field
+
+from langchain_triggers.core import (
+    TriggerRegistrationModel,
+    TriggerHandlerResult,
+    TriggerRegistrationResult,
+)
+from langchain_triggers.decorators import TriggerTemplate
+
+logger = logging.getLogger(__name__)
+
+
+class CronRegistration(TriggerRegistrationModel):
+    """Registration model for cron triggers - just a crontab pattern."""
+
+    crontab: str = Field(
+        ...,
+        description="Cron pattern (e.g., '0 9 * * MON-FRI', '*/15 * * * *')",
+        examples=["0 9 * * MON-FRI", "*/15 * * * *", "0 2 * * SUN"],
+    )
+
+
+async def cron_registration_handler(
+    user_id: str, auth_client: Client, registration: CronRegistration
+) -> TriggerRegistrationResult:
+    """Handle cron trigger registration - validates cron pattern and prepares for scheduling."""
+    logger.info(f"Cron registration request: {registration}")
+
+    cron_pattern = registration.crontab.strip()
+
+    # Validate cron pattern
+    try:
+        if not croniter.is_valid(cron_pattern):
+            return TriggerRegistrationResult(
+                create_registration=False,
+                response_body={
+                    "success": False,
+                    "error": "invalid_cron_pattern",
+                    "message": f"Invalid cron pattern: '{cron_pattern}'"
+                },
+                status_code=400
+            )
+    except Exception as e:
+        return TriggerRegistrationResult(
+            create_registration=False,
+            response_body={
+                "success": False,
+                "error": "cron_validation_failed",
+                "message": f"Failed to validate cron pattern: {str(e)}"
+            },
+            status_code=400
+        )
+
+    logger.info(f"Successfully validated cron pattern: {cron_pattern}")
+    return TriggerRegistrationResult(
+        metadata={
+            "cron_pattern": cron_pattern,
+            "timezone": "UTC",
+            "created_at": datetime.utcnow().isoformat(),
+            "validated": True
+        }
+    )
+
+
+async def cron_trigger_handler(
+    payload: Dict[str, Any],
+    query_params: Dict[str, str],
+    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")
+    return TriggerHandlerResult(
+        invoke_agent=False,
+        response_body={
+            "success": False,
+            "message": "Cron triggers are executed by scheduler, not HTTP requests"
+        }
+    )
+
+
+cron_trigger = TriggerTemplate(
+    id="cron-trigger",
+    name="Cron Scheduler",
+    description="Triggers agents on a cron schedule",
+    registration_model=CronRegistration,
+    registration_handler=cron_registration_handler,
+    trigger_handler=cron_trigger_handler,
+)

{langchain_trigger_server-0.1.9 → langchain_trigger_server-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langchain-trigger-server"
-version = "0.1.9"
+version = "0.1.10"
 description = "Generic event-driven triggers framework"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -33,6 +33,8 @@ dependencies = [
     "langgraph-sdk>=0.2.6",
     "supabase>=2.0.0",
     "cryptography>=3.0.0",
+    "APScheduler>=3.10.0",
+    "croniter>=1.4.0",
 ]
 
 [project.optional-dependencies]