Download core/triggers/execution_service.py from Kyrlos11/nniback: direct link, hf CLI and curl.
- Browser
- Download file 7.01 kB
-
https://huggingface.co/spaces/Kyrlos11/nniback/resolve/main/core/triggers/execution_service.py
- Command line
-
hf download hf://spaces/Kyrlos11/nniback/core/triggers/execution_service.py
-
curl -L -o execution_service.py https://huggingface.co/spaces/Kyrlos11/nniback/resolve/main/core/triggers/execution_service.py
7.01 kB
| """ | |
| Trigger execution service - executes agents when triggers fire. | |
| This is a thin wrapper that reuses existing agent_runs infrastructure. | |
| """ | |
| import json | |
| import uuid | |
| from datetime import datetime, timezone | |
| from typing import Dict, Any, Optional | |
| from core.services.supabase import DBConnection | |
| from core.services import redis | |
| from core.utils.logger import logger, structlog | |
| from core.utils.config import config, EnvMode | |
| from .trigger_service import TriggerEvent, TriggerResult | |
| class ExecutionService: | |
| """Executes agents when triggers fire, reusing core agent_runs infrastructure.""" | |
| def __init__(self, db_connection: DBConnection): | |
| self._db = db_connection | |
| async def execute_trigger_result( | |
| self, | |
| agent_id: str, | |
| trigger_result: TriggerResult, | |
| trigger_event: TriggerEvent | |
| ) -> Dict[str, Any]: | |
| """ | |
| Execute an agent based on trigger result. | |
| Reuses the core agent start infrastructure from agent_runs.py. | |
| """ | |
| if not config.ACTIVATE_MCPS_TRIG: | |
| logger.warning("Trigger execution blocked: ACTIVATE_MCPS_TRIG is disabled") | |
| return {"success": False, "error": "Trigger functionality is disabled"} | |
| try: | |
| client = await self._db.client | |
| agent_result = await client.table('agents').select('account_id').eq('agent_id', agent_id).single().execute() | |
| if not agent_result.data: | |
| return { | |
| "success": False, | |
| "error": f"Agent {agent_id} not found", | |
| "message": "Failed to execute trigger" | |
| } | |
| account_id = agent_result.data['account_id'] | |
| if config.ENV_MODE != EnvMode.LOCAL: | |
| from core.utils.limits_checker import check_project_count_limit, check_thread_limit | |
| project_limit = await check_project_count_limit(account_id) | |
| if not project_limit['can_create']: | |
| logger.warning(f"Trigger execution blocked: project limit reached for account {account_id} ({project_limit['current_count']}/{project_limit['limit']})") | |
| return { | |
| "success": False, | |
| "error": f"Project limit reached ({project_limit['current_count']}/{project_limit['limit']}). Upgrade your plan to run more triggers.", | |
| "message": "Failed to execute trigger - project limit exceeded" | |
| } | |
| thread_limit = await check_thread_limit(account_id) | |
| if not thread_limit['can_create']: | |
| logger.warning(f"Trigger execution blocked: thread limit reached for account {account_id} ({thread_limit['current_count']}/{thread_limit['limit']})") | |
| return { | |
| "success": False, | |
| "error": f"Thread limit reached ({thread_limit['current_count']}/{thread_limit['limit']}). Upgrade your plan to run more triggers.", | |
| "message": "Failed to execute trigger - thread limit exceeded" | |
| } | |
| rendered_prompt = self._render_prompt( | |
| trigger_result.agent_prompt, | |
| trigger_result.execution_variables, | |
| trigger_event | |
| ) | |
| from core.agents.api import start_agent_run | |
| model_name = trigger_result.model if hasattr(trigger_result, 'model') and trigger_result.model else None | |
| result = await start_agent_run( | |
| account_id=account_id, | |
| prompt=rendered_prompt, | |
| agent_id=agent_id, | |
| model_name=model_name, | |
| metadata={ | |
| "trigger_execution": True, | |
| "trigger_id": trigger_event.trigger_id, | |
| "trigger_variables": trigger_result.execution_variables | |
| }, | |
| skip_limits_check=True | |
| ) | |
| return { | |
| "success": True, | |
| "thread_id": result.get("thread_id"), | |
| "agent_run_id": result.get("agent_run_id"), | |
| "message": "Worker execution started successfully" | |
| } | |
| except Exception as e: | |
| logger.error(f"Failed to execute trigger result: {e}", exc_info=True) | |
| return { | |
| "success": False, | |
| "error": str(e), | |
| "message": "Failed to execute trigger" | |
| } | |
| def _render_prompt( | |
| self, | |
| prompt: str, | |
| trigger_variables: Optional[Dict[str, Any]], | |
| trigger_event: TriggerEvent | |
| ) -> str: | |
| """Render trigger variables into the prompt template.""" | |
| rendered = prompt | |
| try: | |
| # Get context from trigger event | |
| ctx = {} | |
| if hasattr(trigger_event, "context") and isinstance(trigger_event.context, dict): | |
| ctx = trigger_event.context | |
| # Merge with execution variables | |
| if trigger_variables: | |
| ctx.update(trigger_variables) | |
| payload = ctx.get("payload") | |
| trigger_slug = ctx.get("trigger_slug") | |
| webhook_id = ctx.get("webhook_id") | |
| def _to_json(obj: Any) -> str: | |
| try: | |
| return json.dumps(obj, ensure_ascii=False, indent=2) | |
| except Exception: | |
| return str(obj) | |
| # Replace template variables | |
| if "{{payload}}" in rendered: | |
| rendered = rendered.replace("{{payload}}", _to_json(payload)) | |
| if "{{trigger_slug}}" in rendered: | |
| rendered = rendered.replace("{{trigger_slug}}", str(trigger_slug or "")) | |
| if "{{webhook_id}}" in rendered: | |
| rendered = rendered.replace("{{webhook_id}}", str(webhook_id or "")) | |
| # Append full context for reference | |
| if ctx: | |
| context_json = _to_json(ctx) | |
| rendered = f"""{rendered}\n\n---\nContext: | |
| **Important Trigger task execution Reminder:** \n | |
| For those tasks whose instructions given by the user aren't clear enough, and you decide to use ask() tool to further clarify any question/aspect before proceeding, send those questions in plain text via email to the personal gmail of the user. | |
| \n \n\n{context_json}""" | |
| except Exception as e: | |
| logger.warning(f"Failed to render prompt variables: {e}") | |
| # Return original prompt on error | |
| return rendered | |
| def get_execution_service(db_connection: DBConnection) -> ExecutionService: | |
| """Factory function for ExecutionService.""" | |
| return ExecutionService(db_connection) | |