langchain-trigger-server 0.2.6rc8__py3-none-any.whl → 0.2.7__py3-none-any.whl

langchain_triggers/auth/__init__.py

@@ -1,10 +1,10 @@
 """Authentication utilities for trigger webhooks."""
 
 from .slack_hmac import (
-    verify_slack_signature,
-    get_slack_signing_secret,
-    extract_slack_headers,
     SlackSignatureVerificationError,
+    extract_slack_headers,
+    get_slack_signing_secret,
+    verify_slack_signature,
 )
 
 __all__ = [
@@ -13,4 +13,3 @@ __all__ = [
     "extract_slack_headers",
     "SlackSignatureVerificationError",
 ]
-

langchain_triggers/auth/slack_hmac.py

@@ -12,13 +12,13 @@ import hmac
 import logging
 import os
 import time
-from typing import Optional
 
 logger = logging.getLogger(__name__)
 
 
 class SlackSignatureVerificationError(Exception):
     """Exception raised when Slack signature verification fails."""
+
     pass
 
 
@@ -27,13 +27,13 @@ def verify_slack_signature(
     timestamp: str,
     body: str,
     signature: str,
-    max_age_seconds: int = 300
+    max_age_seconds: int = 300,
 ) -> bool:
     try:
         # Verify timestamp to prevent replay attacks
         current_time = int(time.time())
         request_time = int(timestamp)
-        
+
         if abs(current_time - request_time) > max_age_seconds:
             logger.error(
                 f"Slack request timestamp too old. "
@@ -43,27 +43,27 @@ def verify_slack_signature(
             raise SlackSignatureVerificationError(
                 f"Request timestamp is too old (>{max_age_seconds}s). Possible replay attack."
             )
-        
+
         # Format: v0:{timestamp}:{body}
         sig_basestring = f"v0:{timestamp}:{body}"
-        
+
         # Create HMAC-SHA256 hash
-        my_signature = 'v0=' + hmac.new(
-            signing_secret.encode(),
-            sig_basestring.encode(),
-            hashlib.sha256
-        ).hexdigest()
-        
+        my_signature = (
+            "v0="
+            + hmac.new(
+                signing_secret.encode(), sig_basestring.encode(), hashlib.sha256
+            ).hexdigest()
+        )
+
         if not hmac.compare_digest(my_signature, signature):
             logger.error(
-                f"Slack signature mismatch. "
-                f"Expected: {my_signature}, Got: {signature}"
+                f"Slack signature mismatch. Expected: {my_signature}, Got: {signature}"
             )
             raise SlackSignatureVerificationError("Signature verification failed")
-        
+
         logger.info("Successfully verified Slack webhook signature")
         return True
-        
+
     except ValueError as e:
         logger.error(f"Invalid timestamp format: {e}")
         raise SlackSignatureVerificationError(f"Invalid timestamp: {str(e)}")
@@ -72,7 +72,7 @@ def verify_slack_signature(
         raise SlackSignatureVerificationError(f"Verification error: {str(e)}")
 
 
-def get_slack_signing_secret() -> Optional[str]:
+def get_slack_signing_secret() -> str | None:
     """Get Slack signing secret from SLACK_SIGNING_SECRET environment variable."""
     secret = os.getenv("SLACK_SIGNING_SECRET")
     if not secret:
@@ -80,16 +80,11 @@ def get_slack_signing_secret() -> Optional[str]:
     return secret
 
 
-def extract_slack_headers(headers: dict) -> tuple[Optional[str], Optional[str]]:
+def extract_slack_headers(headers: dict) -> tuple[str | None, str | None]:
     """Extract Slack signature and timestamp from request headers."""
-    signature = (
-        headers.get('x-slack-signature') or 
-        headers.get('X-Slack-Signature')
-    )
-    timestamp = (
-        headers.get('x-slack-request-timestamp') or 
-        headers.get('X-Slack-Request-Timestamp')
+    signature = headers.get("x-slack-signature") or headers.get("X-Slack-Signature")
+    timestamp = headers.get("x-slack-request-timestamp") or headers.get(
+        "X-Slack-Request-Timestamp"
     )
-    
-    return signature, timestamp
 
+    return signature, timestamp

langchain_triggers/core.py

@@ -3,51 +3,59 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
+
 from pydantic import BaseModel, Field
 
 logger = logging.getLogger(__name__)
 
 
-
 class ProviderAuthInfo(BaseModel):
     """Authentication info for a specific OAuth provider."""
-    
-    token: Optional[str] = None
+
+    token: str | None = None
     auth_required: bool = False
-    auth_url: Optional[str] = None
-    auth_id: Optional[str] = None
+    auth_url: str | None = None
+    auth_id: str | None = None
 
 
 class UserAuthInfo(BaseModel):
     """User authentication info containing OAuth tokens or auth requirements."""
-    
+
     user_id: str
-    providers: Dict[str, ProviderAuthInfo] = Field(default_factory=dict)
-    
+    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)
+    thread_id: str | None = 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_messages: Optional[list[str]] = Field(default=None, description="List of messages to send to agents (one invocation per message)")
-    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)")
-    
+
+    invoke_agent: bool = Field(
+        default=True, description="Whether to invoke agents for this event"
+    )
+    agent_messages: list[str] | None = Field(
+        default=None,
+        description="List of messages to send to agents (one invocation per message)",
+    )
+    response_body: dict[str, Any] | None = Field(
+        default=None, description="Custom HTTP response body (when invoke_agent=False)"
+    )
+    registration: dict[str, Any] | None = 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_messages:
@@ -60,19 +68,35 @@ class TriggerHandlerResult(BaseModel):
 
 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)")
-    
+
+    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: dict[str, Any] | None = Field(
+        default=None,
+        description="Custom HTTP response body (when create_registration=False)",
+    )
+    status_code: int | None = 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")
+        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
+
+    pass

langchain_triggers/cron_manager.py

@@ -2,14 +2,12 @@
 
 import logging
 from datetime import datetime
-from typing import Dict, Any, Optional
+from typing import Any
 
 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
 from langchain_triggers.triggers.cron_trigger import CRON_TRIGGER_ID
 
 logger = logging.getLogger(__name__)
@@ -17,27 +15,27 @@ 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
+    completion_time: datetime | None = None
     status: str  # "running", "completed", "failed"
-    error_message: Optional[str] = None
+    error_message: str | None = None
     agents_invoked: int = 0
 
 
 class CronTriggerManager:
     """Manages dynamic cron job scheduling based on database registrations."""
-    
+
     def __init__(self, trigger_server):
-        self.scheduler = AsyncIOScheduler(timezone='UTC')
+        self.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:
@@ -46,19 +44,21 @@ class CronTriggerManager:
         except Exception as e:
             logger.error(f"Failed to start CronTriggerManager: {e}")
             raise
-            
+
     async def shutdown(self):
         """Shutdown scheduler gracefully."""
         try:
             self.scheduler.shutdown(wait=True)
         except Exception as e:
             logger.error(f"Error shutting down CronTriggerManager: {e}")
-            
+
     async def _load_existing_registrations(self):
         """Load all existing cron registrations from database and schedule them."""
         try:
-            registrations = await self.trigger_server.database.get_all_registrations(CRON_TRIGGER_ID)
-            
+            registrations = await self.trigger_server.database.get_all_registrations(
+                CRON_TRIGGER_ID
+            )
+
             scheduled_count = 0
             for registration in registrations:
                 if registration.get("status") == "active":
@@ -66,68 +66,74 @@ class CronTriggerManager:
                         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.error(
+                            f"Failed to schedule existing cron job {registration.get('id')}: {e}"
+                        )
+
         except Exception as e:
             logger.error(f"Failed to load existing cron registrations: {e}")
-    
+
     async def reload_from_database(self):
         """Reload all cron registrations from database, replacing current schedules."""
         try:
             # Clear all current jobs
             for registration_id in list(self.active_jobs.keys()):
                 await self._unschedule_cron_job(registration_id)
-            
+
             # Reload from database
             await self._load_existing_registrations()
 
         except Exception as e:
             logger.error(f"Failed to reload cron jobs from database: {e}")
             raise
-    
-    async def on_registration_created(self, registration: Dict[str, Any]):
+
+    async def on_registration_created(self, registration: dict[str, Any]):
         """Called when a new cron registration is created."""
         if registration.get("trigger_template_id") == CRON_TRIGGER_ID:
             try:
                 await self._schedule_cron_job(registration)
             except Exception as e:
-                logger.error(f"Failed to schedule new cron job {registration['id']}: {e}")
+                logger.error(
+                    f"Failed to schedule new cron job {registration['id']}: {e}"
+                )
                 raise
-                
+
     async def on_registration_deleted(self, registration_id: str):
         """Called when a cron registration is deleted."""
         try:
             await self._unschedule_cron_job(registration_id)
         except Exception as e:
             logger.error(f"Failed to unschedule cron job {registration_id}: {e}")
-    
-    async def _schedule_cron_job(self, registration: Dict[str, Any]):
+
+    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}")
-        
+            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, 
+                hour=hour,
                 day=day,
                 month=month,
                 day_of_week=day_of_week,
-                timezone='UTC'
+                timezone="UTC",
             )
-            
+
             # Schedule the job
             job = self.scheduler.add_job(
                 self._execute_cron_job_with_monitoring,
@@ -136,15 +142,17 @@ class CronTriggerManager:
                 id=f"cron_{registration_id}",
                 name=f"Cron job for registration {registration_id}",
                 max_instances=1,  # Prevent overlapping executions
-                replace_existing=True
+                replace_existing=True,
             )
 
             self.active_jobs[registration_id] = job.id
 
         except Exception as e:
-            logger.error(f"Failed to schedule cron job for registration {registration_id}: {e}")
+            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:
@@ -156,9 +164,11 @@ class CronTriggerManager:
                 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]):
+            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"]
@@ -168,31 +178,35 @@ class CronTriggerManager:
             cron_pattern=cron_pattern,
             scheduled_time=datetime.utcnow(),
             actual_start_time=datetime.utcnow(),
-            status="running"
+            status="running",
         )
 
         try:
             agents_invoked = await self.execute_cron_job(registration)
             execution.status = "completed"
             execution.agents_invoked = agents_invoked
-            logger.info(f"✓ Cron job {registration_id} completed successfully - invoked {agents_invoked} agent(s)")
+            logger.info(
+                f"✓ Cron job {registration_id} completed successfully - invoked {agents_invoked} agent(s)"
+            )
 
         except Exception as e:
             execution.status = "failed"
             execution.error_message = str(e)
             logger.error(f"✗ Cron job {registration_id} failed: {e}")
-            
+
         finally:
             execution.completion_time = datetime.utcnow()
             await self._record_execution(execution)
-    
-    async def execute_cron_job(self, registration: Dict[str, Any]) -> int:
+
+    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
-        agent_links = await self.trigger_server.database.get_agents_for_trigger(registration_id)
+        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}")
@@ -200,7 +214,11 @@ 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")
+            agent_id = (
+                agent_link
+                if isinstance(agent_link, str)
+                else agent_link.get("agent_id")
+            )
             # Ensure agent_id and user_id are strings for JSON serialization
             agent_id_str = str(agent_id)
             user_id_str = str(user_id)
@@ -210,7 +228,10 @@ class CronTriggerManager:
 
             agent_input = {
                 "messages": [
-                    {"role": "human", "content": f"ACTION: triggering cron from langchain-trigger-server\nCURRENT TIME: {current_time_str}"}
+                    {
+                        "role": "human",
+                        "content": f"ACTION: triggering cron from langchain-trigger-server\nCURRENT TIME: {current_time_str}",
+                    }
                 ]
             }
 
@@ -224,31 +245,33 @@ class CronTriggerManager:
                     agents_invoked += 1
 
             except Exception as e:
-                logger.error(f"✗ Error invoking agent {agent_id_str} for cron job {registration_id}: {e}")
+                logger.error(
+                    f"✗ Error invoking agent {agent_id_str} for cron job {registration_id}: {e}"
+                )
 
         return agents_invoked
-    
+
     async def _record_execution(self, execution: CronJobExecution):
         """Record execution history (in memory for now)."""
         self.execution_history.append(execution)
-        
+
         # Keep only recent executions
         if len(self.execution_history) > self.max_history:
-            self.execution_history = self.execution_history[-self.max_history:]
-    
-    def get_active_jobs(self) -> Dict[str, str]:
+            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]:
+
+    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())
-        }
+            "active_job_ids": list(self.active_jobs.keys()),
+        }

langchain_triggers/database/__init__.py

@@ -6,11 +6,11 @@ from .supabase import SupabaseTriggerDatabase
 
 def create_database(database_type: str, **kwargs) -> TriggerDatabaseInterface:
     """Factory function to create database implementation."""
-    
+
     if database_type == "supabase":
         return SupabaseTriggerDatabase(**kwargs)
     else:
         raise ValueError(f"Unknown database type: {database_type}")
 
 
-__all__ = ["TriggerDatabaseInterface", "SupabaseTriggerDatabase", "create_database"]
+__all__ = ["TriggerDatabaseInterface", "SupabaseTriggerDatabase", "create_database"]