langchain-trigger-server 0.3__py3-none-any.whl → 0.3.3__py3-none-any.whl

{langchain_trigger_server-0.3.dist-info → langchain_trigger_server-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-trigger-server
-Version: 0.3
+Version: 0.3.3
 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.3.dist-info/RECORD

@@ -0,0 +1,15 @@
+langchain_triggers/__init__.py,sha256=WoW9LC_FJRs42mLWq2iuM-jjPow2Rue50q2zm56Oul0,536
+langchain_triggers/app.py,sha256=-VytRXkAPI8qm-fbMJMbQ52Qt8WC2nKBgL_8FGJaFTM,40468
+langchain_triggers/core.py,sha256=6r_91UWt7c26TVqkDxHc2xjmaQl42g-iFHGEWuDo0gs,3929
+langchain_triggers/cron_manager.py,sha256=PueW_z7gdkSza9J05W1VV2OxsfqvodMo7ZlAQJKMvpI,16408
+langchain_triggers/decorators.py,sha256=ZhWgUjbl2jUbvGSlqgThebd0tPgqXoQ02D7BcKZ9aIs,4675
+langchain_triggers/auth/__init__.py,sha256=RtDKuBoKYuyHzLNpKr74cmALO0PhHlWO9Ho7k3CUYFE,349
+langchain_triggers/auth/slack_hmac.py,sha256=kiwjhTXITgQvLAtEcOv8BnnWJRJcxaQ9dXkQm3JJDQ4,2948
+langchain_triggers/database/__init__.py,sha256=B1I1qmVr3U1CSf0VkjxsL4W5QGda5T7uB_CsJq6yBF4,535
+langchain_triggers/database/interface.py,sha256=jpADOOwcBQo1ZichgiZVaOvfZqEqVVo8Ea7ATWWTSBE,4283
+langchain_triggers/database/supabase.py,sha256=zi_75GbqRvzzlXd5EgfYof4h6vHWOLS4I1759wvY9kQ,17009
+langchain_triggers/triggers/__init__.py,sha256=Uw1544gxzN4XDRn2RzpZ5EAG6EAF38ZYQtVvlciEsMs,146
+langchain_triggers/triggers/cron_trigger.py,sha256=YTscULtB8JesnB24IWZl0LDMkf-A9Y6dksAk7GLFJiQ,3355
+langchain_trigger_server-0.3.3.dist-info/METADATA,sha256=lSxdTnBzgk9FQKnXa8BIvgfsLi-36RREMkfiVgQU1c0,1486
+langchain_trigger_server-0.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain_trigger_server-0.3.3.dist-info/RECORD,,

langchain_triggers/app.py

@@ -21,10 +21,10 @@ from .auth.slack_hmac import (
     get_slack_signing_secret,
     verify_slack_signature,
 )
+from .core import TriggerType
 from .cron_manager import CronTriggerManager
 from .database import TriggerDatabaseInterface, create_database
 from .decorators import TriggerTemplate
-from .triggers.cron_trigger import CRON_TRIGGER_ID
 
 logger = logging.getLogger(__name__)
 
@@ -366,7 +366,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(
-                    user_id, self.langchain_auth_client, registration_instance
+                    request, user_id, self.langchain_auth_client, registration_instance
                 )
 
                 # Check if handler requested to skip registration (e.g., for OAuth or URL verification)
@@ -419,6 +419,29 @@ class TriggerServer:
                 logger.exception(f"Error creating trigger registration: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
 
+        @self.app.delete("/v1/triggers/registrations/{registration_id}")
+        async def api_delete_registration(
+            registration_id: str,
+            current_user: dict[str, Any] = Depends(get_current_user),
+        ) -> dict[str, Any]:
+            """Delete a trigger registration."""
+            try:
+                user_id = current_user["identity"]
+                success = await self.database.delete_trigger_registration(
+                    registration_id, user_id
+                )
+                if not success:
+                    raise HTTPException(
+                        status_code=500, detail="Failed to delete trigger registration"
+                    )
+                return {"success": True}
+
+            except HTTPException:
+                raise
+            except Exception as e:
+                logger.error(f"Error deleting trigger registration: {e}")
+                raise HTTPException(status_code=500, detail=str(e))
+
         @self.app.get("/v1/triggers/registrations/{registration_id}/agents")
         async def api_list_registration_agents(
             registration_id: str,
@@ -566,12 +589,34 @@ class TriggerServer:
                         detail="Trigger registration not found or access denied",
                     )
 
-                # Get the template to check if it's a cron trigger
+                # Get the template to check if it's a polling trigger
                 template_id = registration.get("template_id")
-                if template_id != CRON_TRIGGER_ID:
+                tmpl = (
+                    next((t for t in self.triggers if t.id == template_id), None)
+                    if template_id
+                    else None
+                )
+                if not template_id or not tmpl:
+                    error_reason = (
+                        "missing_template_id"
+                        if not template_id
+                        else "template_not_found"
+                    )
+                    logger.error(
+                        "manual_execute_error registration_id=%s template_id=%s error=%s",
+                        registration_id,
+                        template_id,
+                        error_reason,
+                        stack_info=True,
+                    )
+                    raise HTTPException(status_code=500, detail="Internal server error")
+                if (
+                    getattr(tmpl.trigger_type, "value", tmpl.trigger_type)
+                    != TriggerType.POLLING.value
+                ):
                     raise HTTPException(
                         status_code=400,
-                        detail="Manual execution is only supported for cron triggers",
+                        detail="Manual execution is only supported for polling triggers",
                     )
 
                 # Execute the cron trigger using the cron manager

langchain_triggers/core.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from enum import Enum
 from typing import Any
 
 from pydantic import BaseModel, Field
@@ -10,6 +11,13 @@ from pydantic import BaseModel, Field
 logger = logging.getLogger(__name__)
 
 
+class TriggerType(str, Enum):
+    """Type of trigger supported by the framework."""
+
+    WEBHOOK = "webhook"
+    POLLING = "polling"
+
+
 class ProviderAuthInfo(BaseModel):
     """Authentication info for a specific OAuth provider."""
 

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.triggers.cron_trigger import CRON_TRIGGER_ID
+from langchain_triggers.core import TriggerHandlerResult, TriggerType
 
 logger = logging.getLogger(__name__)
 
@@ -36,10 +36,19 @@ class CronTriggerManager:
         self.execution_history = []  # Keep recent execution history
         self.max_history = 1000
 
+    def _is_polling(self, trigger) -> bool:
+        ttype = getattr(trigger, "trigger_type", None)
+        val = getattr(ttype, "value", ttype)
+        try:
+            return str(val).lower() == TriggerType.POLLING.value
+        except Exception:
+            return False
+
     async def start(self):
         """Start scheduler and load existing cron registrations."""
         try:
             self.scheduler.start()
+            logger.info("polling_manager_started timezone=UTC")
             await self._load_existing_registrations()
         except Exception as e:
             logger.error(f"Failed to start CronTriggerManager: {e}")
@@ -53,25 +62,59 @@ class CronTriggerManager:
             logger.error(f"Error shutting down CronTriggerManager: {e}")
 
     async def _load_existing_registrations(self):
-        """Load all existing cron registrations from database and schedule them."""
+        """Load all existing polling registrations from database and schedule them.
+
+        Discovers polling-capable triggers dynamically from registered templates.
+        """
         try:
-            registrations = await self.trigger_server.database.get_all_registrations(
-                CRON_TRIGGER_ID
+            scheduled_total = 0
+            polling_templates = [
+                t for t in self.trigger_server.triggers if self._is_polling(t)
+            ]
+            ids_csv = ",".join([t.id for t in polling_templates]) or ""
+            logger.info(
+                f"polling_templates_loaded count={len(polling_templates)} ids={ids_csv}"
             )
 
-            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}"
+            for template in polling_templates:
+                template_id = template.id
+                logger.info(
+                    "polling_template "
+                    f"template_id={template_id} provider={(template.provider or '').lower()} name={getattr(template, 'name', '')}"
+                )
+                try:
+                    registrations = (
+                        await self.trigger_server.database.get_all_registrations(
+                            template_id
                         )
-
+                    )
+                    logger.info(
+                        f"registrations_fetched template_id={template_id} count={len(registrations)}"
+                    )
+                except Exception as e:
+                    logger.error(
+                        f"registrations_fetch_err template_id={template_id} error={str(e)}"
+                    )
+                    continue
+
+                scheduled_for_template = 0
+                for registration in registrations:
+                    if registration.get("status") == "active":
+                        try:
+                            await self._schedule_cron_job(registration)
+                            scheduled_total += 1
+                            scheduled_for_template += 1
+                        except Exception as e:
+                            logger.error(
+                                "registration_schedule_err "
+                                f"registration_id={registration.get('id')} template_id={template_id} error={str(e)}"
+                            )
+                logger.debug(
+                    f"registrations_scheduled template_id={template_id} scheduled={scheduled_for_template}"
+                )
+            logger.debug(f"polling_schedule_complete total_scheduled={scheduled_total}")
         except Exception as e:
-            logger.error(f"Failed to load existing cron registrations: {e}")
+            logger.error(f"polling_load_err error={str(e)}")
 
     async def reload_from_database(self):
         """Reload all cron registrations from database, replacing current schedules."""
@@ -88,15 +131,39 @@ class CronTriggerManager:
             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_ID:
+        """Called when a new polling registration is created."""
+        template_id_raw = registration.get("template_id")
+        template_id = str(template_id_raw) if template_id_raw is not None else None
+        if template_id is None:
+            logger.error(
+                "registration_missing_template_id id=%s", registration.get("id")
+            )
+            return
+        tmpl = next(
+            (t for t in self.trigger_server.triggers if t.id == template_id), None
+        )
+        if not tmpl:
+            logger.error(
+                "registration_template_not_found id=%s template_id=%s",
+                registration.get("id"),
+                template_id,
+            )
+            return
+        if self._is_polling(tmpl):
             try:
                 await self._schedule_cron_job(registration)
             except Exception as e:
                 logger.error(
-                    f"Failed to schedule new cron job {registration['id']}: {e}"
+                    f"Failed to schedule new cron job {registration.get('id')}: {e}"
                 )
                 raise
+        else:
+            logger.debug(
+                "registration_not_polling id=%s template_id=%s trigger_type=%s",
+                registration.get("id"),
+                template_id,
+                tmpl.trigger_type,
+            )
 
     async def on_registration_deleted(self, registration_id: str):
         """Called when a cron registration is deleted."""
@@ -106,25 +173,36 @@ class CronTriggerManager:
             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."""
+        """Add a polling job to the scheduler using a 5-field crontab."""
         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}"
-            )
+        crontab = (resource_data.get("crontab") or "").strip()
+        template_id = registration.get("template_id")
+        template_id = str(template_id) if template_id is not None else None
+        tmpl = next(
+            (t for t in self.trigger_server.triggers if t.id == template_id), None
+        )
+        if tmpl and not crontab:
+            crontab = (getattr(tmpl, "default_crontab", None) or "").strip()
 
         try:
-            # Parse cron expression
-            cron_parts = crontab.strip().split()
+            if not crontab:
+                if template_id is None:
+                    raise ValueError(
+                        f"No schedule provided for registration {registration_id} (missing template_id)"
+                    )
+                if tmpl is None:
+                    raise ValueError(
+                        f"No schedule provided for registration {registration_id} (template '{template_id}' not found)"
+                    )
+                raise ValueError(
+                    f"No schedule provided for registration {registration_id} (no crontab and no default_crontab for template '{template_id}')"
+                )
+
+            cron_parts = crontab.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,
@@ -133,15 +211,18 @@ class CronTriggerManager:
                 day_of_week=day_of_week,
                 timezone="UTC",
             )
+            job_id = f"cron_{registration_id}"
+            logger.info(
+                f"schedule_cron registration_id={registration_id} crontab='{crontab}' job_id={job_id}"
+            )
 
-            # 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
+                id=job_id,
+                name=f"Polling job for registration {registration_id}",
+                max_instances=1,
                 replace_existing=True,
             )
 
@@ -149,7 +230,7 @@ class CronTriggerManager:
 
         except Exception as e:
             logger.error(
-                f"Failed to schedule cron job for registration {registration_id}: {e}"
+                f"Failed to schedule polling job for registration {registration_id}: {e}"
             )
             raise
 
@@ -202,6 +283,8 @@ class CronTriggerManager:
         """Execute a cron job - invoke agents. Can be called manually or by scheduler."""
         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 = (
             registration.get("metadata", {}).get("client_metadata", {}).get("tenant_id")
         )
@@ -215,45 +298,98 @@ class CronTriggerManager:
             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")
+        tmpl = next(
+            (t for t in self.trigger_server.triggers if t.id == template_id), None
+        )
+
+        if not tmpl or not self._is_polling(tmpl):
+            available_ids = ",".join([t.id for t in self.trigger_server.triggers])
+            logger.error(
+                "template_not_polling "
+                f"template_id={template_id} available_templates={available_ids}"
             )
-            # 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"ACTION: triggering cron from langchain-trigger-server\nCURRENT TIME: {current_time_str}",
-                    }
-                ]
-            }
+            return 0
 
-            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:
-                    agents_invoked += 1
+        result: TriggerHandlerResult = await tmpl.poll_handler(
+            registration,
+            self.trigger_server.database,
+            self.trigger_server.langchain_auth_client,
+        )
 
-            except Exception as e:
-                logger.error(
-                    f"✗ Error invoking agent {agent_id_str} for cron job {registration_id}: {e}"
-                )
+        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 []
+
+        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"ACTION: triggering cron from langchain-trigger-server\nCURRENT TIME: {current_time_str}\n\n{message}",
+                        }
+                    ]
+                }
+
+                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)}"
+        )
         return agents_invoked
 
     async def _record_execution(self, execution: CronJobExecution):

langchain_triggers/decorators.py

@@ -1,14 +1,19 @@
-"""Trigger system - templates with registration and webhook handlers."""
+"""Trigger system - templates with registration and webhook handlers.
+
+Also supports polling triggers (no HTTP route) via a `poll_handler` that the
+framework scheduler can call on a cadence.
+"""
 
 from __future__ import annotations
 
 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
+from .core import TriggerHandlerResult, TriggerRegistrationResult, TriggerType
 
 
 class TriggerTemplate:
@@ -22,7 +27,11 @@ class TriggerTemplate:
         description: str,
         registration_model: type[BaseModel],
         registration_handler,
-        trigger_handler,
+        trigger_handler=None,
+        *,
+        trigger_type: TriggerType = TriggerType.WEBHOOK,
+        poll_handler: Any | None = None,
+        default_crontab: str | None = None,
     ):
         self.id = id
         self.provider = provider
@@ -31,26 +40,44 @@ class TriggerTemplate:
         self.registration_model = registration_model
         self.registration_handler = registration_handler
         self.trigger_handler = trigger_handler
+        self.trigger_type = trigger_type
+        self.poll_handler = poll_handler
+        self.default_crontab = default_crontab
 
         self._validate_handler_signatures()
 
     def _validate_handler_signatures(self):
         """Validate that all handler functions have the correct signatures."""
-        # Expected: async def handler(user_id: str, auth_client: Client, registration: RegistrationModel) -> TriggerRegistrationResult
+        # Expected reg: async def handler(request: Request, user_id: str, auth_client: Client, registration: RegistrationModel) -> TriggerRegistrationResult
         self._validate_handler(
             "registration_handler",
             self.registration_handler,
-            [str, Client, self.registration_model],
+            [Request, str, Client, self.registration_model],
             TriggerRegistrationResult,
         )
 
-        # 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,
-        )
+        if self.trigger_type == TriggerType.WEBHOOK:
+            if not self.trigger_handler:
+                raise TypeError(
+                    f"trigger_handler required for webhook trigger '{self.id}'"
+                )
+            self._validate_handler(
+                "trigger_handler",
+                self.trigger_handler,
+                [dict[str, Any], dict[str, str], Any, Client],
+                TriggerHandlerResult,
+            )
+        else:
+            if not self.poll_handler:
+                raise TypeError(
+                    f"poll_handler required for polling trigger '{self.id}'"
+                )
+            self._validate_handler(
+                "poll_handler",
+                self.poll_handler,
+                [dict[str, Any], Any, Client],
+                TriggerHandlerResult,
+            )
 
     def _validate_handler(
         self,

langchain_triggers/triggers/cron_trigger.py

@@ -5,6 +5,7 @@ from datetime import datetime
 from typing import Any
 
 from croniter import croniter
+from fastapi import Request
 from langchain_auth.client import Client
 from pydantic import Field
 
@@ -12,6 +13,7 @@ from langchain_triggers.core import (
     TriggerHandlerResult,
     TriggerRegistrationModel,
     TriggerRegistrationResult,
+    TriggerType,
 )
 from langchain_triggers.decorators import TriggerTemplate
 
@@ -32,7 +34,7 @@ class CronRegistration(TriggerRegistrationModel):
 
 
 async def cron_registration_handler(
-    user_id: str, auth_client: Client, registration: CronRegistration
+    request: Request, 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}")
@@ -73,20 +75,25 @@ async def cron_registration_handler(
     )
 
 
-async def cron_trigger_handler(
-    payload: dict[str, Any],
-    query_params: dict[str, str],
+async def cron_poll_handler(
+    registration: dict[str, Any],
     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")
+    """Polling handler for generic cron.
+
+    Produces a simple time-based message for linked agents.
+    """
+    current_time = datetime.utcnow()
+    current_time_str = current_time.strftime("%A, %B %d, %Y at %H:%M UTC")
+    message = (
+        "ACTION: triggering cron from langchain-trigger-server\n"
+        f"CURRENT TIME: {current_time_str}"
+    )
     return TriggerHandlerResult(
-        invoke_agent=False,
-        response_body={
-            "success": False,
-            "message": "Cron triggers are executed by scheduler, not HTTP requests",
-        },
+        invoke_agent=True,
+        agent_messages=[message],
+        registration=registration,
     )
 
 
@@ -97,5 +104,6 @@ cron_trigger = TriggerTemplate(
     description="Triggers agents on a cron schedule",
     registration_model=CronRegistration,
     registration_handler=cron_registration_handler,
-    trigger_handler=cron_trigger_handler,
+    trigger_type=TriggerType.POLLING,
+    poll_handler=cron_poll_handler,
 )

langchain_trigger_server-0.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-langchain_triggers/__init__.py,sha256=WoW9LC_FJRs42mLWq2iuM-jjPow2Rue50q2zm56Oul0,536
-langchain_triggers/app.py,sha256=rVl_Yc2n0bz37mPb3E1MnPG2bCXH-bZkuuleaQIII8U,38569
-langchain_triggers/core.py,sha256=_CNZRyj78yCHG8FACwhCmZ0zvRoWls924OIFYMOC27Q,3772
-langchain_triggers/cron_manager.py,sha256=ISo-P2gw7eQ6y7xWQOfojqcJr_K-zagZt9Ocy8nX0fw,10477
-langchain_triggers/decorators.py,sha256=zsfgf171qkEDdIiSn8LUr--3dz6bxBBKZO6dpRM2ILs,3711
-langchain_triggers/auth/__init__.py,sha256=RtDKuBoKYuyHzLNpKr74cmALO0PhHlWO9Ho7k3CUYFE,349
-langchain_triggers/auth/slack_hmac.py,sha256=kiwjhTXITgQvLAtEcOv8BnnWJRJcxaQ9dXkQm3JJDQ4,2948
-langchain_triggers/database/__init__.py,sha256=B1I1qmVr3U1CSf0VkjxsL4W5QGda5T7uB_CsJq6yBF4,535
-langchain_triggers/database/interface.py,sha256=jpADOOwcBQo1ZichgiZVaOvfZqEqVVo8Ea7ATWWTSBE,4283
-langchain_triggers/database/supabase.py,sha256=zi_75GbqRvzzlXd5EgfYof4h6vHWOLS4I1759wvY9kQ,17009
-langchain_triggers/triggers/__init__.py,sha256=Uw1544gxzN4XDRn2RzpZ5EAG6EAF38ZYQtVvlciEsMs,146
-langchain_triggers/triggers/cron_trigger.py,sha256=SeWz_ETBCBO1_r96tzTZgsvn4BdF4yMKabygjmHoGwY,3174
-langchain_trigger_server-0.3.dist-info/METADATA,sha256=eC_TiB7Y3vPvK4pQmx2WFteIHruiI_u_zWDjG9Uqpjc,1484
-langchain_trigger_server-0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langchain_trigger_server-0.3.dist-info/RECORD,,