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

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

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

@@ -1,8 +1,9 @@
 """LangChain Triggers Framework - Event-driven triggers for AI agents."""
 
-from .core import UserAuthInfo, TriggerRegistrationModel, TriggerHandlerResult, TriggerRegistrationResult, MetadataManager
+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"
 
@@ -11,7 +12,7 @@ __all__ = [
     "TriggerRegistrationModel",
     "TriggerHandlerResult",
     "TriggerRegistrationResult",
-    "MetadataManager",
     "TriggerTemplate",
     "TriggerServer",
+    "cron_trigger",
 ]

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

@@ -6,16 +6,15 @@ import logging
 import os
 from typing import Any, Callable, Dict, List, Optional
 
-import httpx
-
 from fastapi import FastAPI, HTTPException, Request, Depends
 from langgraph_sdk import get_client
+from langchain_auth.client import Client
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import Response
 
-from .core import UserAuthInfo, ProviderAuthInfo, MetadataManager
 from .decorators import TriggerTemplate
 from .database import create_database, TriggerDatabaseInterface
+from .cron_manager import CronTriggerManager
 
 logger = logging.getLogger(__name__)
 
@@ -72,7 +71,6 @@ class TriggerServer:
     def __init__(
         self,
         auth_handler: Callable,
-        langgraph_headers_builder: Callable,
     ):
         self.app = FastAPI(
             title="Triggers Server",
@@ -82,11 +80,10 @@ class TriggerServer:
         
         self.database = create_database()
         self.auth_handler = auth_handler
-        self.langgraph_headers_builder = langgraph_headers_builder
         
         # LangGraph configuration
         self.langgraph_api_url = os.getenv("LANGGRAPH_API_URL")
-        self.langgraph_api_key = os.getenv("LANGCHAIN_API_KEY")
+        self.langsmith_api_key = os.getenv("LANGSMITH_API_KEY")
         
         if not self.langgraph_api_url:
             raise ValueError("LANGGRAPH_API_URL environment variable is required")
@@ -94,32 +91,37 @@ class TriggerServer:
         self.langgraph_api_url = self.langgraph_api_url.rstrip("/")
 
         # Initialize LangGraph SDK client
-        self.langgraph_client = get_client(url=self.langgraph_api_url)
+        self.langgraph_client = get_client(url=self.langgraph_api_url, api_key=self.langsmith_api_key)
 
-        self.langchain_auth_client = None
-        try:
-            from langchain_auth import Client
-            langchain_api_key = os.getenv("LANGCHAIN_API_KEY")
-            if langchain_api_key:
-                self.langchain_auth_client = Client(api_key=langchain_api_key)
-                logger.info("Initialized LangChain Auth client for OAuth token injection")
-            else:
-                logger.warning("LANGCHAIN_API_KEY not found - OAuth token injection disabled")
-        except ImportError:
-            logger.warning("langchain_auth not installed - OAuth token injection disabled")
+        # Initialize LangChain auth client
+        langchain_api_key = os.getenv("LANGCHAIN_API_KEY")
+        if langchain_api_key:
+            self.langchain_auth_client = Client(api_key=langchain_api_key)
+            logger.info("✓ LangChain auth client initialized")
+        else:
+            self.langchain_auth_client = None
+            logger.warning("LANGCHAIN_API_KEY not found - OAuth token injection disabled")
         
         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."""
@@ -255,43 +257,31 @@ class TriggerServer:
                 resource_dict = registration_instance.model_dump()
                 existing_registration = await self.database.find_registration_by_resource(
                     template_id=trigger.id,
-                    resource_data=resource_dict,
-                    user_id=user_id
+                    resource_data=resource_dict
                 )
                 
+                # TODO(sam) figure out how to allow duplicates across users.....very unnatural constraint to have
                 if existing_registration:
                     raise HTTPException(
                         status_code=400,
                         detail=f"A registration with this configuration already exists for trigger type '{trigger.id}'. Registration ID: {existing_registration.get('id')}"
                     )
                 
-                # Inject OAuth tokens if needed for registration
-                auth_user = None
-                if trigger.oauth_providers:
-                    try:
-                        auth_user = await self._get_authenticated_user(trigger, user_id)
-                        
-                        # Check if any provider requires authentication - return early if so
-                        for provider in trigger.oauth_providers.keys():
-                            provider_info = auth_user.providers.get(provider)
-                            if provider_info and provider_info.auth_required:
-                                logger.info(f"User {user_id} needs to authenticate for {provider} - returning auth URL")
-                                return {
-                                    "success": True,
-                                    "registered": False,
-                                    "auth_required": True,
-                                    "auth_url": provider_info.auth_url,
-                                    "auth_id": provider_info.auth_id,
-                                    "provider": provider
-                                }
-                        
-                    except Exception as e:
-                        logger.error(f"OAuth authentication failed during registration: {e}")
-                        raise HTTPException(status_code=500, detail="OAuth authentication failed")
-                
                 
                 # Call the trigger's registration handler with parsed registration model
-                result = await trigger.registration_handler(registration_instance, auth_user)
+                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)
+                if not result.create_registration:
+                    logger.info(f"Registration handler requested to skip database creation")
+                    from fastapi import Response
+                    import json
+                    return Response(
+                        content=json.dumps(result.response_body),
+                        status_code=result.status_code,
+                        media_type="application/json"
+                    )
+                
                 resource_dict = registration_instance.model_dump()
 
                 registration = await self.database.create_trigger_registration(
@@ -304,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,
@@ -314,7 +307,7 @@ class TriggerServer:
             except HTTPException:
                 raise
             except Exception as e:
-                logger.error(f"Error creating trigger registration: {e}")
+                logger.exception(f"Error creating trigger registration: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
         
         @self.app.get("/api/triggers/registrations/{registration_id}/agents")
@@ -418,16 +411,6 @@ class TriggerServer:
             except Exception as e:
                 logger.error(f"Error unlinking agent from trigger: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
-        
-        @self.app.get("/events/subscriptions")
-        async def list_event_subscriptions() -> Dict[str, Any]:
-            """List event bus subscriptions."""
-            if hasattr(self.event_bus, "list_subscriptions"):
-                subscriptions = self.event_bus.list_subscriptions()
-            else:
-                subscriptions = {}
-            
-            return {"subscriptions": subscriptions}
     
     
     async def _handle_request(
@@ -437,24 +420,6 @@ class TriggerServer:
     ) -> Dict[str, Any]:
         """Handle an incoming request with a handler function."""
         try:
-            # Step 1: API Key Authentication (required for webhooks)
-            # Check for API key in header first, then query params (for Pub/Sub compatibility)
-            api_key = request.headers.get("x-api-key") or request.query_params.get("api_key")
-            if not api_key:
-                logger.warning("Webhook request missing x-api-key header or api_key query parameter")
-                raise HTTPException(
-                    status_code=401,
-                    detail="Missing x-api-key header or api_key query parameter"
-                )
-            
-            # Validate API key and get user_id
-            user_id = await self.database.validate_api_key(api_key)
-            if not user_id:
-                logger.warning("Invalid API key provided to webhook")
-                raise HTTPException(
-                    status_code=401,
-                    detail="Invalid API key"
-                )
             
             # Parse request data
             if request.method == "POST":
@@ -466,108 +431,35 @@ class TriggerServer:
                     payload = {"raw_body": body.decode("utf-8") if body else ""}
             else:
                 payload = dict(request.query_params)
-            
-            # Step 2: Registration resolution
-            if not trigger.registration_resolver:
-                raise HTTPException(
-                    status_code=500,
-                    detail=f"Trigger {trigger.id} missing required registration_resolver"
-                )
-            
-            # Extract resource identifiers using resolver (gets both query params and payload)
-            resource_data = await trigger.registration_resolver(payload, dict(request.query_params))
-            
-            # Find matching registration for the authenticated user
-            # Convert Pydantic model to dict for database lookup
-            resource_dict = resource_data.model_dump()
-            registration = await self.database.find_registration_by_resource(
-                trigger.id, 
-                resource_dict,
-                user_id
-            )
 
-            if not registration:
-                logger.warning(f"No registration found for user {user_id}, trigger_id={trigger.id} with resource={resource_dict}")
-                raise HTTPException(
-                    status_code=400,
-                    detail=f"No registration found for {trigger.id} with resource {resource_dict}"
-                )
-            
-            # Step 3: Inject OAuth tokens if needed
-            auth_user = None
-            if trigger.oauth_providers and self.langchain_auth_client:
-                try:
-                    auth_user = await self._get_authenticated_user(trigger, user_id)
-                    
-                    # Check if any provider requires re-authentication - this shouldn't happen in webhooks
-                    for provider in trigger.oauth_providers.keys():
-                        provider_info = auth_user.providers.get(provider)
-                        if provider_info and provider_info.auth_required:
-                            logger.error(f"User {user_id} needs to re-authenticate for {provider} - this should have been handled during registration")
-                            return {
-                                "success": False,
-                                "error": f"Authentication required for {provider}",
-                                "message": "User needs to re-authenticate this trigger"
-                            }
-                    
-                except Exception as e:
-                    logger.error(f"OAuth authentication failed: {e}")
-                    # Continue without auth - triggers can handle missing tokens
-            
-            # Step 4: Create metadata manager
-            metadata_manager = MetadataManager(
-                database=self.database,
-                registration_id=registration["id"],
-                initial_metadata=registration.get("metadata", {})
-            )
-            
-            # Step 5: Call handler with parsed registration data
-            result = await trigger.trigger_handler(payload, auth_user, metadata_manager)
-            registration_id = registration["id"]
-            
-            # Check if we should invoke agents
+            query_params = dict(request.query_params)
+            result = await trigger.trigger_handler(payload, query_params, self.database, self.langchain_auth_client)
             if not result.invoke_agent:
-                logger.info(f"Handler requested no agent invocation for registration {registration_id}")
-                return {
-                    "success": True,
-                    "agents_invoked": 0
-                }
-            
-            # Get agents linked to this trigger registration
+                return result.response_body
+
+            registration_id = result.registration["id"]
             agent_links = await self.database.get_agents_for_trigger(registration_id)
-            
-            if not agent_links:
-                logger.info(f"No agents linked to registration {registration_id}")
-                return {
-                    "success": True,
-                    "agents_invoked": 0
-                }
-            
-            logger.info(f"Processing trigger result for registration {registration_id} with {len(agent_links)} linked agents")
-            
-            # Invoke each linked agent
+
             agents_invoked = 0
             for agent_link in agent_links:
                 agent_id = agent_link if isinstance(agent_link, str) else agent_link.get("agent_id")
-                
-                # Use the data string from TriggerHandlerResult directly
+
                 agent_input = {
                     "messages": [
-                        {"role": "human", "content": result.data}
+                        {"role": "human", "content": result.agent_message}
                     ]
                 }
 
                 try:
                     success = await self._invoke_agent(
                         agent_id=agent_id,
-                        user_id=registration["user_id"],
+                        user_id=result.registration["user_id"],
                         input_data=agent_input,
                     )
                     if success:
                         agents_invoked += 1
                 except Exception as e:
                     logger.error(f"Error invoking agent {agent_id}: {e}", exc_info=True)
-            
             logger.info(f"Processed trigger handler, invoked {agents_invoked} agents")
             
             return {
@@ -595,12 +487,10 @@ class TriggerServer:
         logger.info(f"Invoking LangGraph agent {agent_id} for user {user_id}")
         
         try:
-            # Build headers using the custom function
-            headers = await self.langgraph_headers_builder(
-                user_id=user_id,
-                api_key=self.langgraph_api_key,
-                agent_id=agent_id
-            )
+            headers = {
+                "x-auth-scheme": "oap-trigger",
+                "x-supabase-user-id": user_id,
+            }
             
             thread = await self.langgraph_client.threads.create(
                 metadata={
@@ -634,41 +524,6 @@ class TriggerServer:
                 logger.error(f"Error invoking agent {agent_id}: {e}")
                 raise
     
-    async def _get_authenticated_user(self, trigger: TriggerTemplate, user_id: str) -> UserAuthInfo:
-        """Get authenticated user with OAuth tokens for the trigger's required providers."""
-        providers = {}
-        
-        # Get tokens for each required OAuth provider
-        for provider, scopes in trigger.oauth_providers.items():
-            try:
-                auth_result = await self.langchain_auth_client.authenticate(
-                    provider=provider,
-                    scopes=scopes,
-                    user_id=user_id
-                )
-                
-                # Debug logging
-                logger.info(f"Auth result for {provider}: {vars(auth_result) if hasattr(auth_result, '__dict__') else 'Not available'}")
-                
-                if hasattr(auth_result, 'token') and auth_result.token:
-                    providers[provider] = ProviderAuthInfo(token=auth_result.token)
-                    logger.debug(f"Successfully got {provider} token for user {user_id}")
-                elif hasattr(auth_result, 'auth_required') and auth_result.auth_required:
-                    logger.info(f"User {user_id} needs to authenticate for {provider}")
-                    providers[provider] = ProviderAuthInfo(
-                        auth_required=True,
-                        auth_url=getattr(auth_result, 'auth_url', None),
-                        auth_id=getattr(auth_result, 'auth_id', None)
-                    )
-                else:
-                    logger.warning(f"No token returned for {provider} provider")
-                    
-            except Exception as e:
-                logger.error(f"Failed to get {provider} token: {e}")
-                # Continue with other providers
-        
-        return UserAuthInfo(user_id=user_id, providers=providers)
-    
     def get_app(self) -> FastAPI:
         """Get the FastAPI app instance."""
         return self.app

langchain_trigger_server-0.1.10/langchain_triggers/core.py

@@ -0,0 +1,78 @@
+"""Core types and interfaces for the triggers framework."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+
+
+class ProviderAuthInfo(BaseModel):
+    """Authentication info for a specific OAuth provider."""
+    
+    token: Optional[str] = None
+    auth_required: bool = False
+    auth_url: Optional[str] = None
+    auth_id: Optional[str] = None
+
+
+class UserAuthInfo(BaseModel):
+    """User authentication info containing OAuth tokens or auth requirements."""
+    
+    user_id: str
+    providers: Dict[str, ProviderAuthInfo] = Field(default_factory=dict)
+    
+    class Config:
+        arbitrary_types_allowed = True
+
+
+
+
+class AgentInvocationRequest(BaseModel):
+    """Request to invoke an AI agent."""
+    
+    assistant_id: str
+    user_id: str
+    input_data: Any
+    thread_id: Optional[str] = None
+    metadata: Dict[str, Any] = Field(default_factory=dict)
+
+
+class TriggerHandlerResult(BaseModel):
+    """Result returned by trigger handlers."""
+    invoke_agent: bool = Field(default=True, description="Whether to invoke agents for this event")
+    agent_message: Optional[str] = Field(default=None, description="String message to send to agents")
+    response_body: Optional[Dict[str, Any]] = Field(default=None, description="Custom HTTP response body (when invoke_agent=False)")
+    registration: Optional[Dict[str, Any]] = Field(default=None, description="Registration data (required when invoke_agent=True)")
+    
+    def model_post_init(self, __context) -> None:
+        """Validate that required fields are provided based on invoke_agent."""
+        if self.invoke_agent and not self.agent_message:
+            raise ValueError("agent_message is required when invoke_agent=True")
+        if self.invoke_agent and not self.registration:
+            raise ValueError("registration is required when invoke_agent=True")
+        if not self.invoke_agent and not self.response_body:
+            raise ValueError("response_body is required when invoke_agent=False")
+
+
+class TriggerRegistrationResult(BaseModel):
+    """Result returned by registration handlers."""
+    create_registration: bool = Field(default=True, description="Whether to create database registration (False = return custom response)")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Metadata to store with the registration")
+    response_body: Optional[Dict[str, Any]] = Field(default=None, description="Custom HTTP response body (when create_registration=False)")
+    status_code: Optional[int] = Field(default=None, description="HTTP status code (when create_registration=False)")
+    
+    def model_post_init(self, __context) -> None:
+        """Validate that required fields are provided based on create_registration."""
+        if self.create_registration and not self.metadata:
+            self.metadata = {}  # Allow empty metadata for create_registration=True
+        if not self.create_registration and (not self.response_body or not self.status_code):
+            raise ValueError("Both response_body and status_code are required when create_registration=False")
+
+
+class TriggerRegistrationModel(BaseModel):
+    """Base class for trigger resource models that define how webhooks are matched to registrations."""
+    pass

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.8 → langchain_trigger_server-0.1.10}/langchain_triggers/database/interface.py

@@ -61,10 +61,14 @@ class TriggerDatabaseInterface(ABC):
     async def find_registration_by_resource(
         self, 
         template_id: str, 
-        resource_data: Dict[str, Any],
-        user_id: str
+        resource_data: Dict[str, Any]
     ) -> Optional[Dict[str, Any]]:
-        """Find trigger registration by matching resource data for a specific user."""
+        """Find trigger registration by matching resource data."""
+        pass
+    
+    @abstractmethod
+    async def get_all_registrations(self, template_id: str) -> List[Dict[str, Any]]:
+        """Get all registrations for a specific trigger template."""
         pass
     
     @abstractmethod
@@ -130,7 +134,3 @@ class TriggerDatabaseInterface(ABC):
         """Get user ID by email from trigger registrations."""
         pass
 
-    @abstractmethod
-    async def validate_api_key(self, api_key: str) -> Optional[str]:
-        """Validate API key and return user_id if valid, None if invalid."""
-        pass

{langchain_trigger_server-0.1.8 → langchain_trigger_server-0.1.10}/langchain_triggers/database/supabase.py

@@ -143,7 +143,7 @@ class SupabaseTriggerDatabase(TriggerDatabaseInterface):
             return response.data[0] if response.data else None
             
         except Exception as e:
-            logger.error(f"Error creating trigger registration: {e}")
+            logger.exception(f"Error creating trigger registration: {e}")
             return None
     
     async def get_user_trigger_registrations(self, user_id: str) -> List[Dict[str, Any]]:
@@ -225,15 +225,14 @@ class SupabaseTriggerDatabase(TriggerDatabaseInterface):
     async def find_registration_by_resource(
         self, 
         template_id: str, 
-        resource_data: Dict[str, Any],
-        user_id: str
+        resource_data: Dict[str, Any]
     ) -> Optional[Dict[str, Any]]:
-        """Find trigger registration by matching resource data for a specific user."""
+        """Find trigger registration by matching resource data."""
         try:
-            # Build query to match against trigger_registrations with template_id and user_id filters
+            # 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("user_id", user_id)
+            ).eq("trigger_templates.id", template_id)
             
             # Add resource field matches
             for field, value in resource_data.items():
@@ -249,6 +248,18 @@ class SupabaseTriggerDatabase(TriggerDatabaseInterface):
             logger.error(f"Error finding registration by resource: {e}")
             return None
     
+    async def get_all_registrations(self, template_id: str) -> List[Dict[str, Any]]:
+        """Get all registrations for a specific trigger template."""
+        try:
+            response = self.client.table("trigger_registrations").select(
+                "*, trigger_templates(id, name, description)"
+            ).eq("template_id", template_id).execute()
+            
+            return response.data or []
+        except Exception as e:
+            logger.error(f"Error getting all registrations for template {template_id}: {e}")
+            return []
+    
     # ========== Agent-Trigger Links ==========
     
     async def link_agent_to_trigger(
@@ -346,30 +357,3 @@ class SupabaseTriggerDatabase(TriggerDatabaseInterface):
             logger.error(f"Error getting user by email: {e}")
             return None
 
-    async def validate_api_key(self, api_key: str) -> Optional[str]:
-        """Validate API key and return user_id if valid, None if invalid."""
-        try:
-            # Query all user API keys to find a match
-            response = self.client.table("user_api_keys").select("user_id, key_hash").execute()
-            
-            if not response.data:
-                return None
-            
-            # Check each encrypted key to see if it matches the provided key
-            for row in response.data:
-                try:
-                    decrypted_key = self._decrypt_secret(row["key_hash"])
-                    if decrypted_key == api_key:
-                        logger.info(f"Valid API key authenticated for user: {row['user_id']}")
-                        return row["user_id"]
-                except Exception as e:
-                    # Skip keys that fail to decrypt
-                    logger.debug(f"Failed to decrypt API key: {e}")
-                    continue
-            
-            logger.warning(f"Invalid API key provided")
-            return None
-            
-        except Exception as e:
-            logger.error(f"Error validating API key: {e}")
-            return None

{langchain_trigger_server-0.1.8 → langchain_trigger_server-0.1.10}/langchain_triggers/decorators.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 import inspect
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Type, get_type_hints
-from .core import UserAuthInfo, TriggerRegistrationModel, TriggerHandlerResult, TriggerRegistrationResult, MetadataManager
+from typing import Any, Dict, List, Type, get_type_hints
+from langchain_auth.client import Client
+from .core import TriggerHandlerResult, TriggerRegistrationResult
 from pydantic import BaseModel
 
 class TriggerTemplate:
@@ -19,9 +20,6 @@ class TriggerTemplate:
 
         registration_handler,
         trigger_handler,
-        registration_resolver,
-
-        oauth_providers: Optional[Dict[str, List[str]]] = None,
     ):
         self.id = id
         self.name = name
@@ -29,21 +27,17 @@ class TriggerTemplate:
         self.registration_model = registration_model
         self.registration_handler = registration_handler
         self.trigger_handler = trigger_handler
-        self.registration_resolver = registration_resolver
-        self.oauth_providers = oauth_providers or {}
 
         self._validate_handler_signatures()
     
     def _validate_handler_signatures(self):
         """Validate that all handler functions have the correct signatures."""
-        # Expected: async def handler(registration: RegistrationModel, auth_user: UserAuthInfo) -> TriggerRegistrationResult
-        self._validate_handler("registration_handler", self.registration_handler, [self.registration_model, UserAuthInfo], TriggerRegistrationResult)
+        # Expected: async def handler(user_id: str, auth_client: Client, registration: RegistrationModel) -> TriggerRegistrationResult
+        self._validate_handler("registration_handler", self.registration_handler, [str, Client, self.registration_model], TriggerRegistrationResult)
         
-        # Expected: async def handler(payload: Dict[str, Any], auth_user: UserAuthInfo, metadata: MetadataManager) -> TriggerHandlerResult
-        self._validate_handler("trigger_handler", self.trigger_handler, [Dict[str, Any], UserAuthInfo, MetadataManager], TriggerHandlerResult)
+        # 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)
         
-        # Expected: async def resolver(payload: Dict[str, Any], query_params: Dict[str, str]) -> RegistrationModel
-        self._validate_handler("registration_resolver", self.registration_resolver, [Dict[str, Any], Dict[str, str]], self.registration_model)
     
     def _validate_handler(self, handler_name: str, handler_func, expected_types: List[Type], expected_return_type: Type = None):
         """Common validation logic for all handler functions."""

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.8 → langchain_trigger_server-0.1.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langchain-trigger-server"
-version = "0.1.8"
+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]

langchain_trigger_server-0.1.8/langchain_triggers/core.py

@@ -1,83 +0,0 @@
-"""Core types and interfaces for the triggers framework."""
-
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-from pydantic import BaseModel, Field
-
-
-
-class ProviderAuthInfo(BaseModel):
-    """Authentication info for a specific OAuth provider."""
-    
-    token: Optional[str] = None
-    auth_required: bool = False
-    auth_url: Optional[str] = None
-    auth_id: Optional[str] = None
-
-
-class UserAuthInfo(BaseModel):
-    """User authentication info containing OAuth tokens or auth requirements."""
-    
-    user_id: str
-    providers: Dict[str, ProviderAuthInfo] = Field(default_factory=dict)
-    
-    class Config:
-        arbitrary_types_allowed = True
-
-
-class MetadataManager:
-    """Manages trigger registration metadata with database persistence."""
-    
-    def __init__(self, database: Any, registration_id: str, initial_metadata: Dict[str, Any]):
-        self.database = database
-        self.registration_id = registration_id
-        self.metadata = initial_metadata.copy()
-    
-    def get(self, key: str, default: Any = None) -> Any:
-        """Get a metadata value by key."""
-        return self.metadata.get(key, default)
-    
-    async def update(self, updates: Dict[str, Any]) -> None:
-        """Update metadata and persist to database."""
-        # Update local state
-        self.metadata.update(updates)
-        
-        # Persist to database
-        await self.database.update_trigger_metadata(self.registration_id, updates)
-
-
-
-class AgentInvocationRequest(BaseModel):
-    """Request to invoke an AI agent."""
-    
-    assistant_id: str
-    user_id: str
-    input_data: Any
-    thread_id: Optional[str] = None
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-
-
-class TriggerHandlerResult(BaseModel):
-    """Result returned by trigger handlers."""
-    
-    invoke_agent: bool = Field(default=True, description="Whether to invoke agents for this event")
-    data: Optional[str] = Field(default=None, description="String data to send to agents")
-    
-    def model_post_init(self, __context) -> None:
-        """Validate that data is provided when invoke_agent is True."""
-        if self.invoke_agent and not self.data:
-            raise ValueError("data field is required when invoke_agent is True")
-
-
-class TriggerRegistrationResult(BaseModel):
-    """Result returned by registration handlers."""
-    
-    metadata: Dict[str, Any] = Field(default_factory=dict, description="Metadata to store with the registration")
-
-
-class TriggerRegistrationModel(BaseModel):
-    """Base class for trigger resource models that define how webhooks are matched to registrations."""
-    
-    class Config:
-        arbitrary_types_allowed = True