langchain-trigger-server 0.2.2__tar.gz → 0.2.4__tar.gz

{langchain_trigger_server-0.2.2 → langchain_trigger_server-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-trigger-server
-Version: 0.2.2
+Version: 0.2.4
 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.2 → langchain_trigger_server-0.2.4}/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
@@ -261,7 +272,7 @@ class TriggerServer:
             try:
                 payload = await request.json()
                 logger.info(f"Registration payload received: {payload}")
-                
+
                 user_id = current_user["identity"]
                 trigger_id = payload.get("type")
                 if not trigger_id:
@@ -270,7 +281,7 @@ class TriggerServer:
                 trigger = next((t for t in self.triggers if t.id == trigger_id), None)
                 if not trigger:
                     raise HTTPException(status_code=400, detail=f"Unknown trigger type: {trigger_id}")
-                
+
                 # Parse payload into registration model first
                 try:
                     registration_instance = trigger.registration_model(**payload)
@@ -287,15 +298,12 @@ class TriggerServer:
                     template_id=trigger.id,
                     resource_data=resource_dict
                 )
-                
+
                 if existing_registration:
                     raise HTTPException(
                         status_code=400,
                         detail=f"You already have a registration with this configuration for trigger type '{trigger.id}'. Registration ID: {existing_registration.get('id')}"
                     )
-                
-                
-                # Call the trigger's registration handler with parsed registration model
                 result = await trigger.registration_handler(user_id, self.langchain_auth_client, registration_instance)
                 
                 # Check if handler requested to skip registration (e.g., for OAuth or URL verification)
@@ -409,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}",
@@ -432,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(
@@ -555,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.2 → langchain_trigger_server-0.2.4}/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__)
 
@@ -58,7 +59,7 @@ class CronTriggerManager:
     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:
@@ -91,7 +92,7 @@ class CronTriggerManager:
     
     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']}")
@@ -170,7 +171,10 @@ class CronTriggerManager:
         """Execute a scheduled cron job with full monitoring and error handling."""
         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,
@@ -178,17 +182,17 @@ class CronTriggerManager:
             actual_start_time=datetime.utcnow(),
             status="running"
         )
-        
-        logger.info(f"🕐 Executing cron job {registration_id} with pattern '{cron_pattern}'")
-        
+
+        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")
-            
+
         except Exception as e:
-            execution.status = "failed" 
+            execution.status = "failed"
             execution.error_message = str(e)
             logger.error(f"✗ Cron job {registration_id} failed: {e}")
             
@@ -196,14 +200,16 @@ 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}")
             return 0
@@ -211,16 +217,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,
@@ -230,10 +236,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.2 → langchain_trigger_server-0.2.4}/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.2 → langchain_trigger_server-0.2.4}/langchain_triggers/database/supabase.py

@@ -259,7 +259,7 @@ class SupabaseTriggerDatabase(TriggerDatabaseInterface):
             # Build query to match against trigger_registrations with template_id filter
             query = self.client.table("trigger_registrations").select(
                 "*, trigger_templates(id, name, description)"
-            ).eq("trigger_templates.id", template_id)
+            ).eq("template_id", template_id)
             
             # Add resource field matches
             for field, value in resource_data.items():
@@ -286,7 +286,7 @@ class SupabaseTriggerDatabase(TriggerDatabaseInterface):
             # 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("trigger_templates.id", template_id).eq("user_id", user_id)
+            ).eq("template_id", template_id).eq("user_id", user_id)
             
             # Add resource field matches
             for field, value in resource_data.items():

{langchain_trigger_server-0.2.2 → langchain_trigger_server-0.2.4}/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.2 → langchain_trigger_server-0.2.4}/pyproject.toml

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