langchain-trigger-server 0.3.22__py3-none-any.whl

langchain_triggers/triggers/cron_trigger.py

@@ -0,0 +1,177 @@
+"""Cron-based trigger for scheduled agent execution."""
+
+import logging
+import uuid
+from datetime import datetime
+from typing import Any
+
+from croniter import croniter
+from fastapi import Request
+from langgraph_sdk import get_client
+from pydantic import Field
+
+from langchain_triggers.core import (
+    TriggerRegistrationModel,
+    TriggerRegistrationResult,
+    TriggerType,
+)
+from langchain_triggers.decorators import TriggerTemplate
+from langchain_triggers.util import (
+    create_service_auth_headers,
+    get_langgraph_url,
+    is_assistant_triggers_paused,
+)
+
+logger = logging.getLogger(__name__)
+
+# Global constant for cron trigger ID (UUID format to match database schema)
+CRON_TRIGGER_ID = "c809e66e-0000-4000-8000-000000000001"
+
+
+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(
+    request: Request, user_id: str, 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_poll_handler(
+    registration: dict[str, Any],
+    database,
+) -> dict[str, Any]:
+    """Polling handler for generic cron - invokes agents directly."""
+    registration_id = registration["id"]
+    user_id = str(registration["user_id"])
+    tenant_id = str(registration.get("tenant_id", ""))
+    organization_id = str(registration.get("organization_id", ""))
+    langgraph_url = get_langgraph_url(registration)
+
+    agent_links = await database.get_agents_for_trigger(registration_id)
+
+    if not agent_links:
+        logger.info(f"cron_no_linked_agents registration_id={registration_id}")
+        return {"success": True, "message": "No linked agents", "agents_invoked": 0}
+
+    client = get_client(url=langgraph_url, api_key=None)
+    headers = create_service_auth_headers(user_id, tenant_id, organization_id)
+
+    current_time = datetime.utcnow()
+    current_time_str = current_time.strftime("%A, %B %d, %Y at %H:%M UTC")
+
+    agents_invoked = 0
+    for agent_link in agent_links:
+        agent_id = str(
+            agent_link if isinstance(agent_link, str) else agent_link.get("agent_id")
+        )
+
+        paused = await is_assistant_triggers_paused(client, agent_id, headers)
+        if paused:
+            logger.info(
+                f"cron_triggers_paused_skip agent_id={agent_id} registration_id={registration_id}"
+            )
+            continue
+
+        try:
+            thread_id = str(uuid.uuid4())
+
+            try:
+                thread_result = await client.threads.create(
+                    thread_id=thread_id,
+                    if_exists="do_nothing",
+                    metadata={
+                        "triggered_by": "cron-trigger",
+                        "user_id": user_id,
+                        "tenant_id": tenant_id,
+                        "registration_id": str(registration_id),
+                    },
+                    headers=headers,
+                )
+                logger.info(
+                    f"cron_thread_create_success thread_id={thread_id} result={thread_result}"
+                )
+            except Exception as thread_err:
+                logger.exception(
+                    f"cron_thread_create_failed thread_id={thread_id} error={str(thread_err)}"
+                )
+
+            await client.runs.create(
+                thread_id,
+                agent_id,
+                input={
+                    "messages": [
+                        {
+                            "role": "human",
+                            "content": f"Cron trigger fired at {current_time_str}",
+                        }
+                    ]
+                },
+                headers=headers,
+                metadata={"source": "trigger"},
+            )
+            logger.info(
+                f"cron_run_ok registration_id={registration_id} agent_id={agent_id} thread_id={thread_id}"
+            )
+            agents_invoked += 1
+        except Exception as e:
+            logger.exception(
+                f"cron_run_err registration_id={registration_id} agent_id={agent_id} error={str(e)}"
+            )
+
+    return {"success": True, "agents_invoked": agents_invoked}
+
+
+cron_trigger = TriggerTemplate(
+    id=CRON_TRIGGER_ID,
+    description="Triggers agents on a predetermined schedule",
+    registration_model=CronRegistration,
+    registration_handler=cron_registration_handler,
+    trigger_type=TriggerType.POLLING,
+    poll_handler=cron_poll_handler,
+    display_name="Cron",
+    integration=None,
+)

langchain_triggers/util.py

@@ -0,0 +1,122 @@
+"""Utility functions for trigger handlers."""
+
+import logging
+import os
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import jwt
+from langgraph_sdk.client import LangGraphClient
+
+logger = logging.getLogger(__name__)
+
+
+def get_x_service_jwt_token(
+    payload: dict[str, Any] | None = None, expiration_seconds: int = 60 * 60
+) -> str:
+    """Create X-Service-Key JWT token for service-to-service authentication.
+
+    Args:
+        payload: Optional payload to include in JWT
+        expiration_seconds: Token expiration time in seconds (default 1 hour)
+
+    Returns:
+        JWT token string
+    """
+    exp_datetime = datetime.now(tz=UTC) + timedelta(seconds=expiration_seconds)
+    exp = int(exp_datetime.timestamp())
+
+    payload = payload or {}
+    payload = {
+        "sub": "unspecified",
+        "exp": exp,
+        **payload,
+    }
+
+    secret = os.environ["X_SERVICE_AUTH_JWT_SECRET"]
+
+    return jwt.encode(
+        payload,
+        secret,
+        algorithm="HS256",
+    )
+
+
+def create_service_auth_headers(
+    user_id: str,
+    tenant_id: str,
+    organization_id: str,
+) -> dict[str, str]:
+    """Create authentication headers with X-Service-Key JWT token.
+
+    Args:
+        user_id: User ID for the request
+        tenant_id: Tenant ID for the request
+
+    Returns:
+        Dictionary of authentication headers
+    """
+    headers = {
+        "x-api-key": "",
+        "x-auth-scheme": "langsmith-agent",
+        "x-user-id": user_id,
+        "x-tenant-id": tenant_id,
+        "x-organization-id": organization_id,
+        "x-service-key": get_x_service_jwt_token(
+            payload={
+                "tenant_id": tenant_id,
+                "user_id": user_id,
+            }
+        ),
+    }
+
+    return headers
+
+
+def get_langgraph_url(registration: dict[str, Any]) -> str:
+    """Get the LangGraph API URL for a given registration
+    by comparing the registration's organization ID to the
+    LANGCHAIN_ORGANIZATION_ID setting."""
+    reg_organization_id = str(registration.get("organization_id"))
+
+    langgraph_api_url = os.getenv("LANGGRAPH_API_URL", "http://localhost:2024")
+    langgraph_api_url_public = os.getenv(
+        "LANGGRAPH_API_URL_PUBLIC", "http://localhost:2024"
+    )
+    langchain_organization_id = os.getenv(
+        "LANGCHAIN_ORGANIZATION_ID", "f5c798a2-2155-4999-ad27-6d466bd26e1c"
+    )
+
+    return (
+        langgraph_api_url
+        if reg_organization_id == langchain_organization_id
+        else langgraph_api_url_public
+    )
+
+
+async def is_assistant_triggers_paused(
+    client: LangGraphClient, agent_id: str, headers: dict[str, str] | None = None
+) -> bool:
+    """Check if triggers are paused for the given assistant.
+
+    Looks for a boolean `triggers_paused` under `assistant.config.configurable`.
+    If the assistant cannot be fetched or the field is absent, returns False.
+    """
+    try:
+        assistant = await client.assistants.get(agent_id, headers=headers)
+        if not assistant:
+            logger.warning(
+                f"assistant_triggers_paused_check_failed agent_id={agent_id} error=assistant_not_found"
+            )
+            return False
+        config = assistant.get("config") or {}
+        configurable = config.get("configurable") or {}
+        paused = bool(configurable.get("triggers_paused", False))
+        if paused:
+            logger.debug(f"assistant_triggers_paused agent_id={agent_id} paused=True")
+        return paused
+    except Exception as e:
+        logger.warning(
+            f"assistant_triggers_paused_check_failed agent_id={agent_id} error={str(e)}"
+        )
+        return False