langchain-trigger-server 0.2.3__tar.gz → 0.2.5__tar.gz

{langchain_trigger_server-0.2.3 → langchain_trigger_server-0.2.5}/PKG-INFO

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

{langchain_trigger_server-0.2.3 → langchain_trigger_server-0.2.5}/langchain_triggers/app.py

@@ -15,6 +15,7 @@ from starlette.responses import Response
 from .decorators import TriggerTemplate
 from .database import create_database, TriggerDatabaseInterface
 from .cron_manager import CronTriggerManager
+from .triggers.cron_trigger import CRON_TRIGGER_ID
 
 logger = logging.getLogger(__name__)
 
@@ -71,17 +72,27 @@ class TriggerServer:
     def __init__(
         self,
         auth_handler: Callable,
+        database: Optional[TriggerDatabaseInterface] = None,
+        database_type: Optional[str] = "supabase",
+        **database_kwargs: Any,
     ):
         # Configure uvicorn logging to use consistent formatting
         self._configure_uvicorn_logging()
-        
+
         self.app = FastAPI(
             title="Triggers Server",
             description="Event-driven triggers framework",
             version="0.1.0"
         )
-        
-        self.database = create_database()
+
+        # 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.auth_handler = auth_handler
         
         # LangGraph configuration
@@ -406,21 +417,21 @@ class TriggerServer:
             """Remove an agent from a trigger registration."""
             try:
                 user_id = current_user["identity"]
-                
+
                 # Verify the trigger registration exists and belongs to the user
                 registration = await self.database.get_trigger_registration(registration_id, user_id)
                 if not registration:
                     raise HTTPException(status_code=404, detail="Trigger registration not found or access denied")
-                
+
                 # Unlink the agent from the trigger
                 success = await self.database.unlink_agent_from_trigger(
                     agent_id=agent_id,
                     registration_id=registration_id
                 )
-                
+
                 if not success:
                     raise HTTPException(status_code=500, detail="Failed to unlink agent from trigger")
-                
+
                 return {
                     "success": True,
                     "message": f"Successfully unlinked agent {agent_id} from trigger {registration_id}",
@@ -429,12 +440,43 @@ class TriggerServer:
                         "agent_id": agent_id
                     }
                 }
-                
+
             except HTTPException:
                 raise
             except Exception as e:
                 logger.error(f"Error unlinking agent from trigger: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
+
+        @self.app.post("/api/triggers/registrations/{registration_id}/execute")
+        async def api_execute_trigger_now(registration_id: str, current_user: Dict[str, Any] = Depends(get_current_user)) -> Dict[str, Any]:
+            """Manually execute a cron trigger registration immediately."""
+            try:
+                user_id = current_user["identity"]
+
+                # Verify the trigger registration exists and belongs to the user
+                registration = await self.database.get_trigger_registration(registration_id, user_id)
+                if not registration:
+                    raise HTTPException(status_code=404, detail="Trigger registration not found or access denied")
+
+                # Get the template to check if it's a cron trigger
+                template_id = registration.get("template_id")
+                if template_id != CRON_TRIGGER_ID:
+                    raise HTTPException(status_code=400, detail="Manual execution is only supported for cron triggers")
+
+                # Execute the cron trigger using the cron manager
+                agents_invoked = await self.cron_manager.execute_cron_job(registration)
+
+                return {
+                    "success": True,
+                    "message": f"Manually executed cron trigger {registration_id}",
+                    "agents_invoked": agents_invoked
+                }
+
+            except HTTPException:
+                raise
+            except Exception as e:
+                logger.error(f"Error executing trigger: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
     
     
     async def _handle_request(
@@ -552,4 +594,4 @@ class TriggerServer:
     
     def get_app(self) -> FastAPI:
         """Get the FastAPI app instance."""
-        return self.app
+        return self.app

{langchain_trigger_server-0.2.3 → langchain_trigger_server-0.2.5}/langchain_triggers/cron_manager.py

@@ -10,6 +10,7 @@ from croniter import croniter
 from pydantic import BaseModel
 
 from langchain_triggers.core import TriggerHandlerResult
+from langchain_triggers.triggers.cron_trigger import CRON_TRIGGER_ID
 
 logger = logging.getLogger(__name__)
 
@@ -42,7 +43,6 @@ class CronTriggerManager:
         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
@@ -51,14 +51,13 @@ class CronTriggerManager:
         """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")
+            registrations = await self.trigger_server.database.get_all_registrations(CRON_TRIGGER_ID)
             
             scheduled_count = 0
             for registration in registrations:
@@ -68,8 +67,6 @@ class CronTriggerManager:
                         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}")
@@ -83,18 +80,16 @@ class CronTriggerManager:
             
             # 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":
+        if registration.get("trigger_template_id") == CRON_TRIGGER_ID:
             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
@@ -103,7 +98,6 @@ class CronTriggerManager:
         """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}")
     
@@ -144,10 +138,9 @@ class CronTriggerManager:
                 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
@@ -159,7 +152,6 @@ class CronTriggerManager:
             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
@@ -171,9 +163,6 @@ class CronTriggerManager:
         registration_id = registration["id"]
         cron_pattern = registration["resource"]["crontab"]
 
-        # Log immediately when callback is invoked to verify APScheduler is calling us
-        logger.info(f"Cron callback invoked for job {registration_id}")
-
         execution = CronJobExecution(
             registration_id=registration_id,
             cron_pattern=cron_pattern,
@@ -182,16 +171,14 @@ class CronTriggerManager:
             status="running"
         )
 
-        logger.info(f"Executing cron job {registration_id} with pattern '{cron_pattern}'")
-        
         try:
-            agents_invoked = await self._execute_cron_job(registration)
+            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")
-            
+            logger.info(f"✓ Cron job {registration_id} completed successfully - invoked {agents_invoked} agent(s)")
+
         except Exception as e:
-            execution.status = "failed" 
+            execution.status = "failed"
             execution.error_message = str(e)
             logger.error(f"✗ Cron job {registration_id} failed: {e}")
             
@@ -199,15 +186,13 @@ class CronTriggerManager:
             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."""
+    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"]
-        
+
         # Get agent links
-        logger.info(f"Querying database for agents linked to cron job {registration_id}")
         agent_links = await self.trigger_server.database.get_agents_for_trigger(registration_id)
-        logger.info(f"Found {len(agent_links) if agent_links else 0} agent links for cron job {registration_id}")
 
         if not agent_links:
             logger.warning(f"No agents linked to cron job {registration_id}")
@@ -216,16 +201,16 @@ class CronTriggerManager:
         agents_invoked = 0
         for agent_link in agent_links:
             agent_id = agent_link if isinstance(agent_link, str) else agent_link.get("agent_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,
@@ -234,11 +219,10 @@ class CronTriggerManager:
                 )
                 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):

{langchain_trigger_server-0.2.3 → langchain_trigger_server-0.2.5}/langchain_triggers/database/__init__.py

@@ -4,7 +4,7 @@ from .interface import TriggerDatabaseInterface
 from .supabase import SupabaseTriggerDatabase
 
 
-def create_database(database_type: str = "supabase", **kwargs) -> TriggerDatabaseInterface:
+def create_database(database_type: str, **kwargs) -> TriggerDatabaseInterface:
     """Factory function to create database implementation."""
     
     if database_type == "supabase":

{langchain_trigger_server-0.2.3 → langchain_trigger_server-0.2.5}/langchain_triggers/triggers/cron_trigger.py

@@ -17,6 +17,9 @@ from langchain_triggers.decorators import TriggerTemplate
 
 logger = logging.getLogger(__name__)
 
+# Global constant for cron trigger ID
+CRON_TRIGGER_ID = "cron-trigger"
+
 
 class CronRegistration(TriggerRegistrationModel):
     """Registration model for cron triggers - just a crontab pattern."""
@@ -88,7 +91,7 @@ async def cron_trigger_handler(
 
 
 cron_trigger = TriggerTemplate(
-    id="cron-trigger",
+    id=CRON_TRIGGER_ID,
     name="Cron Scheduler",
     provider="Cron",
     description="Triggers agents on a cron schedule",

{langchain_trigger_server-0.2.3 → langchain_trigger_server-0.2.5}/pyproject.toml

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