langchain-trigger-server 0.3.6__tar.gz → 0.3.8__tar.gz

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/PKG-INFO

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

@@ -2,7 +2,6 @@
 
 from .app import TriggerServer
 from .core import (
-    TriggerHandlerResult,
     TriggerRegistrationModel,
     TriggerRegistrationResult,
     UserAuthInfo,
@@ -15,7 +14,6 @@ __version__ = "0.1.0"
 __all__ = [
     "UserAuthInfo",
     "TriggerRegistrationModel",
-    "TriggerHandlerResult",
     "TriggerRegistrationResult",
     "TriggerTemplate",
     "TriggerServer",

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/langchain_triggers/app.py

@@ -15,12 +15,6 @@ from langgraph_sdk import get_client
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import Response
 
-from .auth.slack_hmac import (
-    SlackSignatureVerificationError,
-    extract_slack_headers,
-    get_slack_signing_secret,
-    verify_slack_signature,
-)
 from .core import TriggerType
 from .cron_manager import CronTriggerManager
 from .database import TriggerDatabaseInterface
@@ -361,7 +355,7 @@ class TriggerServer:
                         detail=f"You already have a registration with this configuration for trigger type '{trigger.id}'. Registration ID: {existing_registration.get('id')}",
                     )
                 result = await trigger.registration_handler(
-                    request, user_id, self.langchain_auth_client, registration_instance
+                    request, user_id, registration_instance
                 )
 
                 # Check if handler requested to skip registration (e.g., for OAuth or URL verification)
@@ -643,143 +637,18 @@ class TriggerServer:
                 getattr(trigger, "provider", "<unknown>"),
                 request.headers.get("content-type", ""),
             )
-            if request.method == "POST":
-                if request.headers.get("content-type", "").startswith(
-                    "application/json"
-                ):
-                    # Read body once for both auth and parsing
-                    body_bytes = await request.body()
-                    body_str = body_bytes.decode("utf-8")
-                    logger.debug(
-                        "request_body_read bytes=%s",
-                        len(body_bytes) if body_bytes is not None else 0,
-                    )
-
-                    # TODO(sam/palash): We should not have API specific things in this framework repo. We should clean this up.
-                    if self._is_slack_trigger(trigger):
-                        logger.info(
-                            "slack_request_detected trigger_id=%s verifying_signature=true",
-                            getattr(trigger, "id", "<unknown>"),
-                        )
-                        await self._verify_slack_webhook_auth_with_body(
-                            request, body_str
-                        )
 
-                    import json
-
-                    try:
-                        payload = json.loads(body_str)
-                    except Exception as e:
-                        logger.error("json_parse_error error=%s", e)
-                        raise
-                    logger.info(
-                        "payload_parsed kind=json keys=%s",
-                        sorted(payload.keys())
-                        if isinstance(payload, dict)
-                        else "<non-dict>",
-                    )
-
-                    if (
-                        payload.get("type") == "url_verification"
-                        and "challenge" in payload
-                    ):
-                        logger.info("Responding to Slack URL verification challenge")
-                        return {"challenge": payload["challenge"]}
-                else:
-                    # Handle form data or other content types
-                    body = await request.body()
-                    payload = {"raw_body": body.decode("utf-8") if body else ""}
-                    logger.info(
-                        "payload_parsed kind=raw length=%s",
-                        len(payload.get("raw_body", "")),
-                    )
-            else:
-                payload = dict(request.query_params)
-                logger.info(
-                    "payload_parsed kind=query keys=%s",
-                    sorted(payload.keys()),
-                )
-
-            query_params = dict(request.query_params)
             logger.info(
-                "invoking_trigger_handler trigger_id=%s provider=%s query_keys=%s",
+                "invoking_trigger_handler trigger_id=%s provider=%s",
                 getattr(trigger, "id", "<unknown>"),
                 getattr(trigger, "provider", "<unknown>"),
-                sorted(query_params.keys()),
-            )
-            result = await trigger.trigger_handler(
-                payload, query_params, self.database, self.langchain_auth_client
-            )
-            logger.info(
-                "trigger_handler_completed invoke_agent=%s messages=%s has_registration=%s",
-                getattr(result, "invoke_agent", None),
-                len(getattr(result, "agent_messages", []) or []),
-                bool(getattr(result, "registration", None)),
-            )
-            if not result.invoke_agent:
-                logger.info(
-                    "no_agent_invocation trigger_id=%s returning_handler_response=true",
-                    getattr(trigger, "id", "<unknown>"),
-                )
-                return result.response_body
-
-            registration_id = result.registration["id"]
-            agent_links = await self.database.get_agents_for_trigger(registration_id)
-            logger.info(
-                "agent_links_fetched registration_id=%s count=%s",
-                registration_id,
-                len(agent_links) if agent_links is not None else 0,
             )
-
-            agents_invoked = 0
-            # Iterate through each message and invoke agents for each
-            for message in result.agent_messages:
-                logger.debug(
-                    "processing_agent_message message_len=%s",
-                    len(str(message)) if message is not None else 0,
-                )
-                for agent_link in agent_links:
-                    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(result.registration["user_id"])
-                    tenant_id_str = str(result.registration["tenant_id"])
-
-                    agent_input = {"messages": [{"role": "human", "content": message}]}
-
-                    try:
-                        logger.info(
-                            "invoking_agent assistant_id=%s user_id=%s tenant_id=%s",
-                            agent_id_str,
-                            user_id_str,
-                            tenant_id_str,
-                        )
-                        success = await self._invoke_agent(
-                            agent_id=agent_id_str,
-                            user_id=user_id_str,
-                            tenant_id=tenant_id_str,
-                            input_data=agent_input,
-                        )
-                        if success:
-                            agents_invoked += 1
-                            logger.info(
-                                "agent_invocation_success assistant_id=%s registration_id=%s",
-                                agent_id_str,
-                                registration_id,
-                            )
-                    except Exception as e:
-                        logger.error(
-                            f"Error invoking agent {agent_id_str}: {e}", exc_info=True
-                        )
+            response = await trigger.trigger_handler(request, self.database)
             logger.info(
-                f"Processed trigger handler with {len(result.agent_messages)} messages, invoked {agents_invoked} agents"
+                "trigger_handler_completed trigger_id=%s",
+                getattr(trigger, "id", "<unknown>"),
             )
-
-            return {"success": True, "agents_invoked": agents_invoked}
+            return response
 
         except HTTPException:
             raise
@@ -856,150 +725,6 @@ class TriggerServer:
                 logger.error(f"Error invoking agent {agent_id}: {e}")
                 raise
 
-    def _is_slack_trigger(self, trigger: TriggerTemplate) -> bool:
-        """Check if a trigger is from Slack and requires HMAC signature verification."""
-        return trigger.provider.lower() == "slack" or "slack" in trigger.id.lower()
-
-    async def _verify_slack_webhook_auth(self, request: Request) -> None:
-        """Verify Slack HMAC signature for webhook requests.
-
-        Slack uses HMAC-SHA256 signatures to verify webhook authenticity.
-        The signature is computed from the timestamp, body, and signing secret.
-
-        Args:
-            request: The FastAPI request object
-
-        Raises:
-            HTTPException: If authentication fails
-        """
-        try:
-            signing_secret = get_slack_signing_secret()
-            if not signing_secret:
-                logger.error("SLACK_SIGNING_SECRET environment variable not set")
-                raise HTTPException(
-                    status_code=500,
-                    detail="Slack signing secret not configured on server",
-                )
-
-            headers_dict = dict(request.headers)
-            signature, timestamp = extract_slack_headers(headers_dict)
-
-            if not signature:
-                logger.error("Missing X-Slack-Signature header")
-                raise HTTPException(
-                    status_code=401,
-                    detail="Missing X-Slack-Signature header. Slack webhooks require signature verification.",
-                )
-
-            if not timestamp:
-                logger.error("Missing X-Slack-Request-Timestamp header")
-                raise HTTPException(
-                    status_code=401,
-                    detail="Missing X-Slack-Request-Timestamp header. Slack webhooks require timestamp.",
-                )
-
-            body = await request.body()
-            body_str = body.decode("utf-8")
-
-            try:
-                verify_slack_signature(
-                    signing_secret=signing_secret,
-                    timestamp=timestamp,
-                    body=body_str,
-                    signature=signature,
-                )
-                logger.info(
-                    f"Successfully verified Slack webhook signature. Timestamp: {timestamp}"
-                )
-            except SlackSignatureVerificationError as e:
-                logger.error(f"Slack signature verification failed: {e}")
-                raise HTTPException(
-                    status_code=401,
-                    detail=f"Slack signature verification failed: {str(e)}",
-                )
-
-            # Store verification info in request state
-            request.state.slack_verified = True
-            request.state.slack_timestamp = timestamp
-
-        except HTTPException:
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error during Slack webhook authentication: {e}")
-            raise HTTPException(
-                status_code=500, detail=f"Authentication error: {str(e)}"
-            )
-
-    async def _verify_slack_webhook_auth_with_body(
-        self, request: Request, body_str: str
-    ) -> None:
-        """Verify Slack HMAC signature for webhook requests using pre-read body.
-
-        Slack uses HMAC-SHA256 signatures to verify webhook authenticity.
-        The signature is computed from the timestamp, body, and signing secret.
-
-        Args:
-            request: The FastAPI request object
-            body_str: The request body as a string (already read)
-
-        Raises:
-            HTTPException: If authentication fails
-        """
-        try:
-            signing_secret = get_slack_signing_secret()
-            if not signing_secret:
-                logger.error("SLACK_SIGNING_SECRET environment variable not set")
-                raise HTTPException(
-                    status_code=500,
-                    detail="Slack signing secret not configured on server",
-                )
-
-            headers_dict = dict(request.headers)
-            signature, timestamp = extract_slack_headers(headers_dict)
-
-            if not signature:
-                logger.error("Missing X-Slack-Signature header")
-                raise HTTPException(
-                    status_code=401,
-                    detail="Missing X-Slack-Signature header. Slack webhooks require signature verification.",
-                )
-
-            if not timestamp:
-                logger.error("Missing X-Slack-Request-Timestamp header")
-                raise HTTPException(
-                    status_code=401,
-                    detail="Missing X-Slack-Request-Timestamp header. Slack webhooks require timestamp.",
-                )
-
-            try:
-                verify_slack_signature(
-                    signing_secret=signing_secret,
-                    timestamp=timestamp,
-                    body=body_str,
-                    signature=signature,
-                )
-                logger.info(
-                    f"Successfully verified Slack webhook signature. Timestamp: {timestamp}"
-                )
-            except SlackSignatureVerificationError as e:
-                logger.error(f"Slack signature verification failed: {e}")
-                raise HTTPException(
-                    status_code=401,
-                    detail=f"Slack signature verification failed: {str(e)}",
-                )
-
-            # Store verification info in request state
-            request.state.slack_verified = True
-            request.state.slack_timestamp = timestamp
-
-        except HTTPException:
-            raise
-        except Exception as e:
-            logger.error(f"Unexpected error during Slack webhook authentication: {e}")
-            raise HTTPException(
-                status_code=500, detail=f"Authentication error: {str(e)}"
-            )
-
     def get_app(self) -> FastAPI:
         """Get the FastAPI app instance."""
         return self.app

langchain_trigger_server-0.3.8/langchain_triggers/auth/__init__.py

@@ -0,0 +1,3 @@
+"""Authentication utilities for trigger webhooks."""
+
+__all__ = []

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/langchain_triggers/core.py

@@ -47,33 +47,6 @@ class AgentInvocationRequest(BaseModel):
     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: 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:
-            raise ValueError("agent_messages 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."""
 

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/langchain_triggers/cron_manager.py

@@ -8,7 +8,7 @@ from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from apscheduler.triggers.cron import CronTrigger as APSCronTrigger
 from pydantic import BaseModel
 
-from langchain_triggers.core import TriggerHandlerResult, TriggerType
+from langchain_triggers.core import TriggerType
 
 logger = logging.getLogger(__name__)
 
@@ -280,21 +280,10 @@ class CronTriggerManager:
             await self._record_execution(execution)
 
     async def execute_cron_job(self, registration: dict[str, Any]) -> int:
-        """Execute a cron job - invoke agents. Can be called manually or by scheduler."""
+        """Execute a cron job - calls poll handler which invokes agents."""
         registration_id = registration["id"]
-        user_id = registration["user_id"]
         template_id = registration.get("template_id")
         template_id = str(template_id) if template_id is not None else None
-        tenant_id = str(registration.get("tenant_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
 
         tmpl = next(
             (t for t in self.trigger_server.triggers if t.id == template_id), None
@@ -308,85 +297,18 @@ class CronTriggerManager:
             )
             return 0
 
-        result: TriggerHandlerResult = await tmpl.poll_handler(
+        response = await tmpl.poll_handler(
             registration,
             self.trigger_server.database,
-            self.trigger_server.langchain_auth_client,
         )
 
-        if not result.invoke_agent:
-            logger.info(
-                "poll_result "
-                f"registration_id={registration_id} "
-                f"trigger_id={template_id} "
-                f"provider={(tmpl.provider or '').lower()} "
-                f"invoke_agent=false messages_count=0"
-            )
-            return 0
-
-        agents_invoked = 0
-        messages = result.agent_messages or []
-
+        agents_invoked = response.get("agents_invoked", 0)
         logger.info(
             "poll_result "
             f"registration_id={registration_id} "
             f"trigger_id={template_id} "
             f"provider={(tmpl.provider or '').lower()} "
-            f"invoke_agent=true messages_count={len(messages)} "
-            f"agents_linked={len(agent_links)}"
-        )
-
-        for _message in messages:
-            for agent_link in agent_links:
-                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)
-                tenant_id_str = str(tenant_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"Cron trigger fired at {current_time_str}",
-                        }
-                    ]
-                }
-
-                try:
-                    success = await self.trigger_server._invoke_agent(
-                        agent_id=agent_id_str,
-                        user_id=user_id_str,
-                        tenant_id=tenant_id_str,
-                        input_data=agent_input,
-                    )
-                    if success:
-                        logger.info(
-                            "invoke_agent_ok "
-                            f"registration_id={registration_id} "
-                            f"agent_id={agent_id_str}"
-                        )
-                        agents_invoked += 1
-                except Exception as e:
-                    logger.error(
-                        "invoke_agent_err "
-                        f"registration_id={registration_id} "
-                        f"agent_id={agent_id_str} "
-                        f"error={str(e)}"
-                    )
-
-        logger.info(
-            "poll_invoke_summary "
-            f"registration_id={registration_id} "
-            f"agents_invoked={agents_invoked} "
-            f"messages_count={len(messages)}"
+            f"agents_invoked={agents_invoked}"
         )
         return agents_invoked
 

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/langchain_triggers/decorators.py

@@ -10,10 +10,9 @@ import inspect
 from typing import Any, get_type_hints
 
 from fastapi import Request
-from langchain_auth.client import Client
 from pydantic import BaseModel
 
-from .core import TriggerHandlerResult, TriggerRegistrationResult, TriggerType
+from .core import TriggerRegistrationResult, TriggerType
 
 
 class TriggerTemplate:
@@ -48,11 +47,11 @@ class TriggerTemplate:
 
     def _validate_handler_signatures(self):
         """Validate that all handler functions have the correct signatures."""
-        # Expected reg: async def handler(request: Request, user_id: str, auth_client: Client, registration: RegistrationModel) -> TriggerRegistrationResult
+        # Expected reg: async def handler(request: Request, user_id: str, registration: RegistrationModel) -> TriggerRegistrationResult
         self._validate_handler(
             "registration_handler",
             self.registration_handler,
-            [Request, str, Client, self.registration_model],
+            [Request, str, self.registration_model],
             TriggerRegistrationResult,
         )
 
@@ -64,8 +63,8 @@ class TriggerTemplate:
             self._validate_handler(
                 "trigger_handler",
                 self.trigger_handler,
-                [dict[str, Any], dict[str, str], Any, Client],
-                TriggerHandlerResult,
+                [Request, Any],
+                dict[str, Any],
             )
         else:
             if not self.poll_handler:
@@ -75,8 +74,8 @@ class TriggerTemplate:
             self._validate_handler(
                 "poll_handler",
                 self.poll_handler,
-                [dict[str, Any], Any, Client],
-                TriggerHandlerResult,
+                [dict[str, Any], Any],
+                dict[str, Any],
             )
 
     def _validate_handler(

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/langchain_triggers/triggers/cron_trigger.py

@@ -1,21 +1,22 @@
 """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 langchain_auth.client import Client
+from langgraph_sdk import get_client
 from pydantic import Field
 
 from langchain_triggers.core import (
-    TriggerHandlerResult,
     TriggerRegistrationModel,
     TriggerRegistrationResult,
     TriggerType,
 )
 from langchain_triggers.decorators import TriggerTemplate
+from langchain_triggers.util import create_service_auth_headers, get_langgraph_url
 
 logger = logging.getLogger(__name__)
 
@@ -34,7 +35,7 @@ class CronRegistration(TriggerRegistrationModel):
 
 
 async def cron_registration_handler(
-    request: Request, user_id: str, auth_client: Client, registration: CronRegistration
+    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}")
@@ -78,18 +79,73 @@ async def cron_registration_handler(
 async def cron_poll_handler(
     registration: dict[str, Any],
     database,
-    auth_client: Client,
-) -> TriggerHandlerResult:
-    """Polling handler for generic cron.
-
-    Produces a simple time-based message for linked agents.
-    """
-    message = "Cron trigger fired"
-    return TriggerHandlerResult(
-        invoke_agent=True,
-        agent_messages=[message],
-        registration=registration,
-    )
+) -> 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", ""))
+
+    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}
+
+    langgraph_url = get_langgraph_url()
+
+    client = get_client(url=langgraph_url, api_key=None)
+    headers = create_service_auth_headers(user_id, tenant_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")
+        )
+
+        try:
+            thread_id = str(uuid.uuid4())
+
+            try:
+                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,
+                )
+            except Exception as thread_err:
+                logger.warning(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,
+            )
+            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.error(
+                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(

langchain_trigger_server-0.3.8/langchain_triggers/util.py

@@ -0,0 +1,73 @@
+"""Utility functions for trigger handlers."""
+
+import os
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import jwt
+
+
+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) -> 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-service-key": get_x_service_jwt_token(
+            payload={
+                "tenant_id": tenant_id,
+                "user_id": user_id,
+            }
+        ),
+    }
+
+    return headers
+
+
+def get_langgraph_url() -> str:
+    """Get LangGraph API URL from environment.
+
+    Returns:
+        LangGraph API URL
+    """
+    return os.environ.get("LANGGRAPH_API_URL", "http://localhost:8123")

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/pyproject.toml

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

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/tests/unit/test_cron_manager_polling_filter.py

@@ -15,16 +15,14 @@ class _DummyRegModel(BaseModel):
     field: str | None = None
 
 
-async def _dummy_reg_handler(request, user_id, auth_client, registration):
+async def _dummy_reg_handler(request, user_id, registration):
     from langchain_triggers.core import TriggerRegistrationResult
 
     return TriggerRegistrationResult()
 
 
-async def _dummy_trigger_handler(payload, query_params, database, auth_client):
-    from langchain_triggers.core import TriggerHandlerResult
-
-    return TriggerHandlerResult(invoke_agent=False, response_body={"ok": True})
+async def _dummy_trigger_handler(request, database):
+    return {"ok": True}
 
 
 class _FakeDB:

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/tests/unit/test_trigger_server_api.py

@@ -30,9 +30,9 @@ class TestRegistration(BaseModel):
     name: str
 
 
-async def dummy_trigger_handler(payload, query_params, database, auth_client):
+async def dummy_trigger_handler(request, database):
     """Dummy trigger handler for test triggers."""
-    return None
+    return {"ok": True}
 
 
 # Mock database class
@@ -399,7 +399,7 @@ async def test_metadata_storage(trigger_server):
     """Test that handler metadata is properly stored."""
     from langchain_triggers import TriggerRegistrationResult, TriggerTemplate
 
-    async def test_registration_handler(request, user_id, auth_client, registration):
+    async def test_registration_handler(request, user_id, registration):
         return TriggerRegistrationResult(metadata={"handler_data": "from_handler"})
 
     test_trigger = TriggerTemplate(

{langchain_trigger_server-0.3.6 → langchain_trigger_server-0.3.8}/uv.lock

@@ -381,7 +381,7 @@ wheels = [
 
 [[package]]
 name = "langchain-trigger-server"
-version = "0.3.5"
+version = "0.3.8"
 source = { editable = "." }
 dependencies = [
     { name = "apscheduler" },

langchain_trigger_server-0.3.8/version_comparison.txt

@@ -0,0 +1 @@
+Current: 0.3.8, PyPI: 0.3.7, Should publish: True

langchain_trigger_server-0.3.6/langchain_triggers/auth/__init__.py

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

langchain_trigger_server-0.3.6/langchain_triggers/auth/slack_hmac.py

@@ -1,90 +0,0 @@
-"""Slack HMAC signature verification for webhook authentication.
-
-Slack uses HMAC-SHA256 signatures to verify webhook authenticity.
-Each request includes an X-Slack-Signature header that must be verified
-against your app's signing secret.
-"""
-
-from __future__ import annotations
-
-import hashlib
-import hmac
-import logging
-import os
-import time
-
-logger = logging.getLogger(__name__)
-
-
-class SlackSignatureVerificationError(Exception):
-    """Exception raised when Slack signature verification fails."""
-
-    pass
-
-
-def verify_slack_signature(
-    signing_secret: str,
-    timestamp: str,
-    body: str,
-    signature: str,
-    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. "
-                f"Current: {current_time}, Request: {request_time}, "
-                f"Diff: {abs(current_time - request_time)}s"
-            )
-            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()
-        )
-
-        if not hmac.compare_digest(my_signature, signature):
-            logger.error(
-                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)}")
-    except Exception as e:
-        logger.error(f"Unexpected error during Slack signature verification: {e}")
-        raise SlackSignatureVerificationError(f"Verification error: {str(e)}")
-
-
-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:
-        logger.warning("SLACK_SIGNING_SECRET environment variable not set")
-    return secret
-
-
-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"
-    )
-
-    return signature, timestamp

langchain_trigger_server-0.3.6/version_comparison.txt

@@ -1 +0,0 @@
-Current: 0.3.6, PyPI: 0.3.5, Should publish: True