langchain-trigger-server 0.1.7__tar.gz → 0.1.9__tar.gz

{langchain_trigger_server-0.1.7 → langchain_trigger_server-0.1.9}/PKG-INFO

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

@@ -1,6 +1,6 @@
 """LangChain Triggers Framework - Event-driven triggers for AI agents."""
 
-from .core import UserAuthInfo, TriggerRegistrationModel, TriggerHandlerResult, TriggerRegistrationResult, MetadataManager
+from .core import UserAuthInfo, TriggerRegistrationModel, TriggerHandlerResult, TriggerRegistrationResult
 from .decorators import TriggerTemplate
 from .app import TriggerServer
 
@@ -11,7 +11,6 @@ __all__ = [
     "TriggerRegistrationModel",
     "TriggerHandlerResult",
     "TriggerRegistrationResult",
-    "MetadataManager",
     "TriggerTemplate",
     "TriggerServer",
 ]

{langchain_trigger_server-0.1.7 → langchain_trigger_server-0.1.9}/langchain_triggers/app.py

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

langchain_trigger_server-0.1.9/langchain_triggers/core.py

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

{langchain_trigger_server-0.1.7 → langchain_trigger_server-0.1.9}/langchain_triggers/database/interface.py

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

{langchain_trigger_server-0.1.7 → langchain_trigger_server-0.1.9}/langchain_triggers/database/supabase.py

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

{langchain_trigger_server-0.1.7 → langchain_trigger_server-0.1.9}/langchain_triggers/decorators.py

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

{langchain_trigger_server-0.1.7 → langchain_trigger_server-0.1.9}/pyproject.toml

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

langchain_trigger_server-0.1.7/langchain_triggers/core.py

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