from fastapi import APIRouter, HTTPException, Depends, Query, Request from fastapi.responses import JSONResponse from typing import Dict, Any, Optional from pydantic import BaseModel from uuid import uuid4 from core.utils.auth_utils import verify_and_get_user_id_from_jwt, get_optional_current_user_id_from_jwt from core.utils.logger import logger from core.utils.config import config, EnvMode from core.services.supabase import DBConnection from core.services.http_client import get_http_client from datetime import datetime import os import hmac import asyncio import json import hashlib import time import re import base64 from .composio_service import ( get_integration_service, ) from .toolkit_service import ToolkitService, ToolsListResponse from .composio_profile_service import ComposioProfileService, ComposioProfile from .composio_trigger_service import ComposioTriggerService from .trigger_schema import TriggerSchemaService from core.triggers.trigger_service import get_trigger_service, TriggerEvent, TriggerType from core.triggers.execution_service import get_execution_service from .client import ComposioClient from core.triggers.api import sync_triggers_to_version_config router = APIRouter(prefix="/composio", tags=["composio"]) db: Optional[DBConnection] = None def initialize(database: DBConnection): global db db = database COMPOSIO_API_BASE = os.getenv("COMPOSIO_API_BASE", "https://backend.composio.dev") def verify_std_webhook(wid: str, wts: str, wsig: str, raw: bytes, hex_secret: str, max_skew: int = 300) -> bool: if not (wid and wts and wsig and hex_secret): return False try: now = int(time.time()) ts_int = int(wts) if abs(now - ts_int) > max_skew: return False except Exception: pass try: key = bytes.fromhex(hex_secret) except Exception: return False msg = wid.encode() + b"." + (wts.encode()) + b"." + raw digest = hmac.new(key, msg, hashlib.sha256).digest() expected_b64 = base64.b64encode(digest).decode() candidates = [] for entry in wsig.split(): entry = entry.strip() if "," in entry: candidates.append(entry.split(",", 1)[1].strip()) elif "=" in entry: candidates.append(entry.split("=", 1)[1].strip()) else: candidates.append(entry) if any(hmac.compare_digest(expected_b64, c) for c in candidates): return True try: expected_hex = digest.hex() if any(hmac.compare_digest(expected_hex, c.lower()) for c in candidates): return True except Exception: pass return False def _parse_sigs(wsig: str): out = [] for part in wsig.split(): part = part.strip() if "," in part: part = part.split(",", 1)[1].strip() elif "=" in part: part = part.split("=", 1)[1].strip() out.append(part) return out def _b64(d: bytes) -> str: return base64.b64encode(d).decode() async def verify_composio(request: Request, secret_env: str = "COMPOSIO_WEBHOOK_SECRET", max_skew: int = 300) -> bool: secret = os.getenv(secret_env, "") if not secret: raise HTTPException(status_code=500, detail="Webhook secret not configured") wid = request.headers.get("webhook-id", "") wts = request.headers.get("webhook-timestamp", "") wsig = request.headers.get("webhook-signature", "") if not (wid and wts and wsig): raise HTTPException(status_code=401, detail="Missing standard-webhooks headers") try: ts = int(wts) if ts > 10**12: ts //= 1000 if abs(int(time.time()) - ts) > max_skew: raise HTTPException(status_code=401, detail="Timestamp outside tolerance") except ValueError: pass raw = await request.body() keys = [("ascii", secret.encode())] try: keys.append(("hex", bytes.fromhex(secret))) except Exception: pass try: keys.append(("b64", base64.b64decode(secret, validate=False))) except Exception: pass msgs = [ ("id.ts.body", wid.encode() + b"." + wts.encode() + b"." + raw), ("ts.body", wts.encode() + b"." + raw), ] header_sigs = _parse_sigs(wsig) for kname, key in keys: for mname, msg in msgs: dig = hmac.new(key, msg, hashlib.sha256).digest() exp_b64 = _b64(dig) if any(hmac.compare_digest(exp_b64, s) for s in header_sigs): request.state._sig_match = (kname, mname, "b64") return True exp_hex = dig.hex() if any(hmac.compare_digest(exp_hex, s.lower()) for s in header_sigs): request.state._sig_match = (kname, mname, "hex") return True request.state._sig_match = ("none", "none", "none") raise HTTPException(status_code=401, detail="Invalid signature") class IntegrateToolkitRequest(BaseModel): toolkit_slug: str profile_name: Optional[str] = None display_name: Optional[str] = None mcp_server_name: Optional[str] = None save_as_profile: bool = True class IntegrationStatusResponse(BaseModel): status: str toolkit: str auth_config_id: str connected_account_id: str mcp_server_id: str final_mcp_url: str profile_id: Optional[str] = None redirect_url: Optional[str] = None class CreateProfileRequest(BaseModel): toolkit_slug: str profile_name: str display_name: Optional[str] = None mcp_server_name: Optional[str] = None is_default: bool = False initiation_fields: Optional[Dict[str, str]] = None custom_auth_config: Optional[Dict[str, str]] = None use_custom_auth: bool = False class ToolsListRequest(BaseModel): toolkit_slug: str limit: int = 50 cursor: Optional[str] = None class ProfileResponse(BaseModel): profile_id: str profile_name: str display_name: str toolkit_slug: str toolkit_name: str mcp_url: str redirect_url: Optional[str] = None connected_account_id: Optional[str] = None is_connected: bool is_default: bool created_at: str @classmethod def from_composio_profile(cls, profile: ComposioProfile) -> "ProfileResponse": return cls( profile_id=profile.profile_id, profile_name=profile.profile_name, display_name=profile.display_name, toolkit_slug=profile.toolkit_slug, toolkit_name=profile.toolkit_name, mcp_url=profile.mcp_url, redirect_url=profile.redirect_url, connected_account_id=getattr(profile, 'connected_account_id', None), is_connected=profile.is_connected, is_default=profile.is_default, created_at=profile.created_at.isoformat() if profile.created_at else datetime.now().isoformat() ) @router.get("/categories") async def list_categories( user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: logger.debug("Fetching Composio categories") toolkit_service = ToolkitService() categories = await toolkit_service.list_categories() return { "success": True, "categories": [cat.dict() for cat in categories], "total": len(categories) } except Exception as e: logger.error(f"Failed to fetch categories: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to fetch categories: {str(e)}") @router.get("/toolkits") async def list_toolkits( limit: int = Query(100, le=500), cursor: Optional[str] = Query(None), search: Optional[str] = Query(None), category: Optional[str] = Query(None), user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: logger.debug(f"Fetching Composio toolkits with limit: {limit}, cursor: {cursor}, search: {search}, category: {category}") service = get_integration_service() if search: result = await service.search_toolkits(search, category=category, limit=limit, cursor=cursor) else: result = await service.list_available_toolkits(limit, cursor=cursor, category=category) return { "success": True, "toolkits": [toolkit.dict() for toolkit in result.get('items', [])], "total_items": result.get('total_items', 0), "total_pages": result.get('total_pages', 0), "current_page": result.get('current_page', 1), "next_cursor": result.get('next_cursor'), "has_more": result.get('next_cursor') is not None } except Exception as e: logger.error(f"Failed to fetch toolkits: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to fetch toolkits: {str(e)}") @router.get("/toolkits/{toolkit_slug}/details") async def get_toolkit_details( toolkit_slug: str, user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: logger.debug(f"Fetching detailed toolkit info for: {toolkit_slug}") toolkit_service = ToolkitService() detailed_toolkit = await toolkit_service.get_detailed_toolkit_info(toolkit_slug) if not detailed_toolkit: raise HTTPException(status_code=404, detail=f"Toolkit {toolkit_slug} not found") return { "success": True, "toolkit": detailed_toolkit.dict() } except HTTPException: raise except Exception as e: logger.error(f"Failed to fetch toolkit details for {toolkit_slug}: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to fetch toolkit details: {str(e)}") @router.post("/integrate", response_model=IntegrationStatusResponse) async def integrate_toolkit( request: IntegrateToolkitRequest, current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> IntegrationStatusResponse: try: integration_user_id = str(uuid4()) logger.debug(f"Generated integration user_id: {integration_user_id} for account: {current_user_id}") service = get_integration_service(db_connection=db) result = await service.integrate_toolkit( toolkit_slug=request.toolkit_slug, account_id=current_user_id, user_id=integration_user_id, profile_name=request.profile_name, display_name=request.display_name, mcp_server_name=request.mcp_server_name, save_as_profile=request.save_as_profile ) return IntegrationStatusResponse( status="integrated", toolkit=result.toolkit.name, auth_config_id=result.auth_config.id, connected_account_id=result.connected_account.id, mcp_server_id=result.mcp_server.id, final_mcp_url=result.final_mcp_url, profile_id=result.profile_id, redirect_url=result.connected_account.redirect_url ) except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: logger.error(f"Integration failed: {e}") raise HTTPException(status_code=500, detail=str(e)) @router.post("/profiles", response_model=ProfileResponse) async def create_profile( request: CreateProfileRequest, current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> ProfileResponse: try: # For Zendesk, we need a unique user_id for each connection # even when using a shared auth config if request.toolkit_slug.lower() == "zendesk": # Create a unique user_id by combining current_user_id with a UUID integration_user_id = f"{current_user_id}-{str(uuid4())[:8]}" logger.debug(f"Generated unique Zendesk user_id: {integration_user_id} for account: {current_user_id}") else: # For other toolkits, use a standard UUID integration_user_id = str(uuid4()) logger.debug(f"Generated integration user_id: {integration_user_id} for account: {current_user_id}") service = get_integration_service(db_connection=db) result = await service.integrate_toolkit( toolkit_slug=request.toolkit_slug, account_id=current_user_id, user_id=integration_user_id, profile_name=request.profile_name, display_name=request.display_name, mcp_server_name=request.mcp_server_name, save_as_profile=True, initiation_fields=request.initiation_fields, custom_auth_config=request.custom_auth_config, use_custom_auth=request.use_custom_auth ) logger.debug(f"Integration result for {request.toolkit_slug}: redirect_url = {result.connected_account.redirect_url}") profile_service = ComposioProfileService(db) profiles = await profile_service.get_profiles(current_user_id, request.toolkit_slug) created_profile = None for profile in profiles: if profile.profile_name == request.profile_name: created_profile = profile break if not created_profile: raise HTTPException(status_code=500, detail="Profile created but not found") logger.debug(f"Returning profile response with redirect_url: {created_profile.redirect_url}") return ProfileResponse.from_composio_profile(created_profile) except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) except Exception as e: logger.error(f"Failed to create profile: {e}") raise HTTPException(status_code=500, detail=str(e)) @router.get("/profiles/check-name-availability") async def check_profile_name_availability( toolkit_slug: str = Query(..., description="The toolkit slug to check against"), profile_name: str = Query(..., description="The profile name to check"), current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: profile_service = ComposioProfileService(db) profiles = await profile_service.get_profiles(current_user_id, toolkit_slug) name_exists = any( profile.profile_name.lower() == profile_name.lower() for profile in profiles ) suggestions = [] if name_exists: base_name = profile_name.rstrip('0123456789').rstrip() counter = 1 existing_names = {p.profile_name.lower() for p in profiles} while len(suggestions) < 3: suggested_name = f"{base_name} {counter}" if suggested_name.lower() not in existing_names: suggestions.append(suggested_name) counter += 1 return { "available": not name_exists, "message": "Profile name is available" if not name_exists else "Profile name already exists", "suggestions": suggestions } except Exception as e: logger.error(f"Failed to check profile name availability: {e}", exc_info=True) raise HTTPException(status_code=500, detail=str(e)) @router.get("/profiles") async def get_profiles( toolkit_slug: Optional[str] = Query(None), current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: profile_service = ComposioProfileService(db) profiles = await profile_service.get_profiles(current_user_id, toolkit_slug) profile_responses = [ProfileResponse.from_composio_profile(profile) for profile in profiles] return { "success": True, "profiles": profile_responses } except Exception as e: logger.error(f"Failed to get profiles: {e}", exc_info=True) return { "success": False, "profiles": [], "error": str(e) } @router.get("/profiles/{profile_id}/mcp-config") async def get_profile_mcp_config( profile_id: str, current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: profile_service = ComposioProfileService(db) mcp_config = await profile_service.get_mcp_config_for_agent(profile_id, account_id=current_user_id) return { "success": True, "mcp_config": mcp_config, "profile_id": profile_id } except Exception as e: logger.error(f"Failed to get MCP config for profile {profile_id}: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get MCP config: {str(e)}") @router.get("/profiles/{profile_id}") async def get_profile_info( profile_id: str, current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: profile_service = ComposioProfileService(db) profile = await profile_service.get_profile(profile_id, current_user_id) if not profile: raise HTTPException(status_code=404, detail="Profile not found") return { "success": True, "profile": { "profile_id": profile.profile_id, "profile_name": profile.profile_name, "toolkit_name": profile.toolkit_name, "toolkit_slug": profile.toolkit_slug, "created_at": profile.created_at.isoformat() if profile.created_at else None } } except HTTPException: raise except Exception as e: logger.error(f"Failed to get profile info for {profile_id}: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get profile info: {str(e)}") @router.get("/integration/{connected_account_id}/status") async def get_integration_status( connected_account_id: str, user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: service = get_integration_service() status = await service.get_integration_status(connected_account_id) return {"connected_account_id": connected_account_id, **status} except Exception as e: logger.error(f"Failed to get status: {e}") raise HTTPException(status_code=500, detail=str(e)) @router.post("/profiles/{profile_id}/discover-tools") async def discover_composio_tools( profile_id: str, current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: try: profile_service = ComposioProfileService(db) config = await profile_service.get_profile_config(profile_id, account_id=current_user_id) if config.get('type') != 'composio': raise HTTPException(status_code=400, detail="Not a Composio profile") mcp_url = config.get('mcp_url') if not mcp_url: raise HTTPException(status_code=400, detail="Profile has no MCP URL") from core.mcp_module.mcp_service import mcp_service result = await mcp_service.discover_custom_tools( request_type="http", config={"url": mcp_url} ) if not result.success: raise HTTPException(status_code=500, detail=f"Failed to discover tools: {result.message}") # logger.debug(f"Discovered {len(result.tools)} tools from Composio profile {profile_id}") return { "success": True, "profile_id": profile_id, "toolkit_name": config.get('toolkit_name', 'Unknown'), "tools": result.tools, "total_tools": len(result.tools) } except HTTPException: raise except Exception as e: logger.error(f"Failed to discover tools for profile {profile_id}: {e}", exc_info=True) raise HTTPException(status_code=500, detail=str(e)) @router.post("/discover-tools/{profile_id}") async def discover_tools_post( profile_id: str, current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ) -> Dict[str, Any]: return await discover_composio_tools(profile_id, current_user_id) @router.get("/toolkits/{toolkit_slug}/icon") async def get_toolkit_icon( toolkit_slug: str, current_user_id: Optional[str] = Depends(get_optional_current_user_id_from_jwt) ): try: toolkit_service = ToolkitService() icon_url = await toolkit_service.get_toolkit_icon(toolkit_slug) if icon_url: return { "success": True, "toolkit_slug": toolkit_slug, "icon_url": icon_url } else: return { "success": False, "toolkit_slug": toolkit_slug, "icon_url": None, "message": "Icon not found" } except Exception as e: logger.error(f"Error getting toolkit icon: {e}") raise HTTPException(status_code=500, detail="Internal server error") @router.post("/toolkits/icons/batch") async def get_toolkit_icons_batch( request: Request, current_user_id: Optional[str] = Depends(get_optional_current_user_id_from_jwt) ): import asyncio try: body = await request.json() toolkit_slugs = body.get("toolkit_slugs", []) if not toolkit_slugs or not isinstance(toolkit_slugs, list): raise HTTPException(status_code=400, detail="toolkit_slugs must be a non-empty list") if len(toolkit_slugs) > 50: toolkit_slugs = toolkit_slugs[:50] toolkit_service = ToolkitService() async def fetch_icon(slug: str): icon_url = await toolkit_service.get_toolkit_icon(slug) return (slug, icon_url) results = await asyncio.gather(*[fetch_icon(slug) for slug in toolkit_slugs]) icons = {slug: icon_url for slug, icon_url in results if icon_url} return { "success": True, "icons": icons } except HTTPException: raise except Exception as e: logger.error(f"Error getting toolkit icons batch: {e}") raise HTTPException(status_code=500, detail="Internal server error") @router.post("/tools/list") async def list_toolkit_tools( request: ToolsListRequest, current_user_id: str = Depends(verify_and_get_user_id_from_jwt) ): try: logger.debug(f"User {current_user_id} requesting tools for toolkit: {request.toolkit_slug}") toolkit_service = ToolkitService() tools_response = await toolkit_service.get_toolkit_tools( toolkit_slug=request.toolkit_slug, limit=request.limit, cursor=request.cursor ) return { "success": True, "tools": [tool.dict() for tool in tools_response.items], "total_items": tools_response.total_items, "current_page": tools_response.current_page, "total_pages": tools_response.total_pages, "next_cursor": tools_response.next_cursor } except Exception as e: logger.error(f"Failed to list toolkit tools for {request.toolkit_slug}: {e}", exc_info=True) raise HTTPException(status_code=500, detail=f"Failed to get toolkit tools: {str(e)}") @router.get("/triggers/apps") async def list_apps_with_triggers( user_id: str = Depends(verify_and_get_user_id_from_jwt), ) -> Dict[str, Any]: try: trigger_service = ComposioTriggerService() return await trigger_service.list_apps_with_triggers() except httpx.HTTPError as e: logger.error(f"Failed to fetch Composio triggers/apps: {e}") raise HTTPException(status_code=502, detail="Composio API error") except Exception as e: logger.error(f"Error building apps-with-triggers list: {e}") raise HTTPException(status_code=500, detail="Internal server error") @router.get("/triggers/apps/{toolkit_slug}") async def list_triggers_for_app( toolkit_slug: str, user_id: str = Depends(verify_and_get_user_id_from_jwt), ) -> Dict[str, Any]: try: trigger_service = ComposioTriggerService() return await trigger_service.list_triggers_for_app(toolkit_slug) except httpx.HTTPError as e: logger.error(f"Failed to fetch triggers for app {toolkit_slug}: {e}") raise HTTPException(status_code=502, detail="Composio API error") except Exception as e: logger.error(f"Error listing triggers for app {toolkit_slug}: {e}") raise HTTPException(status_code=500, detail="Internal server error") @router.get("/triggers/schema/{trigger_slug}") async def get_trigger_schema( trigger_slug: str, user_id: str = Depends(verify_and_get_user_id_from_jwt), ) -> Dict[str, Any]: try: schema_service = TriggerSchemaService() schema = await schema_service.get_trigger_schema(trigger_slug) return schema except HTTPException: raise except Exception as e: logger.error(f"Failed to get trigger schema for {trigger_slug}: {e}", exc_info=True) raise HTTPException(status_code=500, detail="Internal server error") class CreateComposioTriggerRequest(BaseModel): agent_id: str profile_id: str slug: str trigger_config: Dict[str, Any] route: str # 'agent' name: Optional[str] = None agent_prompt: Optional[str] = None connected_account_id: Optional[str] = None webhook_url: Optional[str] = None toolkit_slug: Optional[str] = None model: Optional[str] = None @router.post("/triggers/create") async def create_composio_trigger(req: CreateComposioTriggerRequest, current_user_id: str = Depends(verify_and_get_user_id_from_jwt)) -> Dict[str, Any]: try: client_db = await db.client agent_check = await client_db.table('agents').select('agent_id').eq('agent_id', req.agent_id).eq('account_id', current_user_id).execute() if not agent_check.data: raise HTTPException(status_code=404, detail="Worker not found or access denied") if config.ENV_MODE != EnvMode.LOCAL: from core.utils.limits_checker import check_trigger_limit limit_check = await check_trigger_limit(client_db, current_user_id, req.agent_id, 'app') if not limit_check['can_create']: error_detail = { "message": f"Maximum of {limit_check['limit']} app triggers allowed for your current plan. You have {limit_check['current_count']} app triggers.", "current_count": limit_check['current_count'], "limit": limit_check['limit'], "tier_name": limit_check['tier_name'], "trigger_type": "app", "error_code": "TRIGGER_LIMIT_EXCEEDED" } logger.warning(f"Trigger limit exceeded for account {current_user_id}: {limit_check['current_count']}/{limit_check['limit']} app triggers") raise HTTPException(status_code=402, detail=error_detail) profile_service = ComposioProfileService(db) profile_config = await profile_service.get_profile_config(req.profile_id, account_id=current_user_id) composio_user_id = profile_config.get("user_id") if not composio_user_id: raise HTTPException(status_code=400, detail="Composio profile is missing user_id") toolkit_slug = req.toolkit_slug if not toolkit_slug: toolkit_slug = profile_config.get("toolkit_slug") if not toolkit_slug and req.slug: toolkit_slug = req.slug.split('_')[0].lower() if '_' in req.slug else 'composio' qualified_name = f'composio.{toolkit_slug}' if toolkit_slug and toolkit_slug != 'composio' else 'composio' api_key = os.getenv("COMPOSIO_API_KEY") if not api_key: raise HTTPException(status_code=500, detail="COMPOSIO_API_KEY not configured") url = f"{COMPOSIO_API_BASE}/api/v3/trigger_instances/{req.slug}/upsert" headers = {"x-api-key": api_key, "Content-Type": "application/json"} secret = os.getenv("COMPOSIO_WEBHOOK_SECRET", "") webhook_headers = {"X-Composio-Secret": secret} if secret else {} vercel_bypass = os.getenv("VERCEL_PROTECTION_BYPASS_KEY", "") if vercel_bypass: webhook_headers["X-Vercel-Protection-Bypass"] = vercel_bypass coerced_config = dict(req.trigger_config or {}) try: type_url = f"{COMPOSIO_API_BASE}/api/v3/triggers_types/{req.slug}" async with get_http_client() as http_client: tr = await http_client.get(type_url, headers=headers, timeout=10.0) if tr.status_code == 200: tdata = tr.json() schema = tdata.get("config") or {} props = schema.get("properties") or {} for key, prop in props.items(): if key not in coerced_config: continue val = coerced_config[key] ptype = prop.get("type") if isinstance(prop, dict) else None try: if ptype == "array": if isinstance(val, str): coerced_config[key] = [val] elif ptype == "integer": if isinstance(val, str) and val.isdigit(): coerced_config[key] = int(val) elif ptype == "number": if isinstance(val, str): coerced_config[key] = float(val) elif ptype == "boolean": if isinstance(val, str): coerced_config[key] = val.lower() in ("true", "1", "yes") elif ptype == "string": if isinstance(val, (list, tuple)): # join list into comma-separated string coerced_config[key] = ",".join(str(x) for x in val) elif not isinstance(val, str): coerced_config[key] = str(val) except Exception: pass except Exception: pass body = { "user_id": composio_user_id, "trigger_config": coerced_config, } if req.connected_account_id: body["connected_account_id"] = req.connected_account_id async with get_http_client() as http_client: resp = await http_client.post(url, headers=headers, json=body, timeout=20.0) try: resp.raise_for_status() except httpx.HTTPStatusError: ct = resp.headers.get("content-type", "") if "application/json" in ct: detail = resp.json() else: detail = resp.text logger.error(f"Composio upsert error: {detail}") raise HTTPException(status_code=400, detail=detail) created = resp.json() try: top_keys = list(created.keys()) if isinstance(created, dict) else None logger.debug( "Composio upsert ok", slug=req.slug, status_code=resp.status_code, top_keys=top_keys, ) except Exception: pass composio_trigger_id = None def _extract_id(obj: Dict[str, Any]) -> Optional[str]: if not isinstance(obj, dict): return None cand = ( obj.get("id") or obj.get("trigger_id") or obj.get("triggerId") or obj.get("nano_id") or obj.get("nanoId") or obj.get("triggerNanoId") ) if cand: return cand # Nested shapes for k in ("trigger", "trigger_instance", "triggerInstance", "data", "result"): nested = obj.get(k) if isinstance(nested, dict): nid = _extract_id(nested) if nid: return nid if isinstance(nested, list) and nested: nid = _extract_id(nested[0]) if nid: return nid return None if isinstance(created, dict): composio_trigger_id = _extract_id(created) try: logger.debug( "Composio extracted trigger id", slug=req.slug, extracted_id=composio_trigger_id, ) except Exception: pass if not composio_trigger_id: raise HTTPException(status_code=500, detail="Failed to get Composio trigger id from response") suna_config: Dict[str, Any] = { "provider_id": "composio", "composio_trigger_id": composio_trigger_id, "trigger_slug": req.slug, "qualified_name": qualified_name, "profile_id": req.profile_id, "model": req.model or "kortix/basic", **coerced_config, } if req.agent_prompt: suna_config["agent_prompt"] = req.agent_prompt # Create Suna trigger trigger_service = get_trigger_service(db) trigger = await trigger_service.create_trigger( agent_id=req.agent_id, provider_id="composio", name=req.name or f"{req.slug}", config=suna_config, description=f"Composio event: {req.slug}" ) # Immediately sync triggers to the current version config await sync_triggers_to_version_config(req.agent_id) return { "success": True, "trigger_id": trigger.trigger_id, "agent_id": trigger.agent_id, "provider": "composio", "composio_trigger_id": composio_trigger_id, "slug": req.slug, "config": trigger.config, } except HTTPException: raise except Exception as e: error_msg = str(e) if e else "Unknown error" logger.error(f"Failed to create Composio trigger: {error_msg}") raise HTTPException(status_code=500, detail=error_msg) @router.post("/webhook") async def composio_webhook(request: Request): """Shared Composio webhook endpoint. Verifies secret, matches triggers, and enqueues execution.""" try: # Read raw body first (can only be done once) try: body = await request.body() body_str = body.decode('utf-8') if body else "" logger.info("Composio webhook raw body", body=body_str, body_length=len(body) if body else 0) except Exception as e: logger.info("Composio webhook body read failed", error=str(e)) body_str = "" # Get webhook ID early for logging wid = request.headers.get("webhook-id", "") # Minimal request diagnostics (no secrets) try: client_ip = request.client.host if request.client else None header_names = list(request.headers.keys()) has_auth = bool(request.headers.get("authorization")) has_x_secret = bool(request.headers.get("x-composio-secret") or request.headers.get("X-Composio-Secret")) has_x_trigger = bool(request.headers.get("x-trigger-secret") or request.headers.get("X-Trigger-Secret")) # Parse payload for logging payload_preview = {"keys": []} try: if body_str: _p = json.loads(body_str) payload_preview = { "keys": list(_p.keys()) if isinstance(_p, dict) else [], "id": _p.get("id") if isinstance(_p, dict) else None, "triggerSlug": _p.get("triggerSlug") if isinstance(_p, dict) else None, } except Exception: payload_preview = {"keys": []} except Exception: pass secret = os.getenv("COMPOSIO_WEBHOOK_SECRET") if not secret: logger.error("COMPOSIO_WEBHOOK_SECRET is not configured") raise HTTPException(status_code=500, detail="Webhook secret not configured") # Use robust verifier (tries ASCII/HEX/B64 keys and id.ts.body/ts.body) await verify_composio(request, "COMPOSIO_WEBHOOK_SECRET") # Parse payload for processing try: payload = json.loads(body_str) if body_str else {} except Exception as parse_error: logger.error(f"Failed to parse webhook payload: {parse_error}", payload_raw=body_str) payload = {} # Look for trigger_nano_id in data.trigger_nano_id (the actual Composio trigger instance ID) composio_trigger_id = ( (payload.get("data", {}) or {}).get("trigger_nano_id") ) provider_event_id = ( payload.get("eventId") or payload.get("payload", {}).get("id") or payload.get("id") or wid ) # Derive trigger slug from various shapes trigger_slug = ( payload.get("triggerSlug") or payload.get("type") or (payload.get("data", {}) or {}).get("triggerSlug") or (payload.get("data", {}) or {}).get("type") ) # Basic parsed-field logging (no secrets) try: logger.info( "Composio parsed fields", webhook_id=wid, trigger_slug=trigger_slug, composio_trigger_id=composio_trigger_id, provider_event_id=provider_event_id, payload_keys=list(payload.keys()) if isinstance(payload, dict) else [], ) except Exception: pass client = await db.client # Fetch all active WEBHOOK triggers and filter by provider 'composio' # If neither id nor slug present, ack 200 to avoid Composio retries if not (composio_trigger_id or trigger_slug): logger.warning("No trigger id or slug; acking 200") return JSONResponse(content={"success": True, "matched_triggers": 0}) try: res = await client.table("agent_triggers").select("*").eq("trigger_type", "webhook").eq("is_active", True).execute() rows = res.data or [] except Exception as e: logger.error(f"Error fetching agent_triggers: {e}") rows = [] matched = [] for row in rows: cfg = row.get("config") or {} if not isinstance(cfg, dict): continue prov = cfg.get("provider_id") or row.get("provider_id") if prov != "composio": logger.debug("Composio skip non-provider", trigger_id=row.get("trigger_id"), provider_id=prov) continue # ONLY match by exact composio_trigger_id - no slug fallback cfg_tid = cfg.get("composio_trigger_id") if composio_trigger_id and cfg_tid == composio_trigger_id: logger.info( "Composio EXACT ID MATCH", trigger_id=row.get("trigger_id"), cfg_composio_trigger_id=cfg_tid, payload_composio_trigger_id=composio_trigger_id, is_active=row.get("is_active") ) matched.append(row) continue else: logger.info( "Composio ID mismatch", trigger_id=row.get("trigger_id"), cfg_composio_trigger_id=cfg_tid, payload_composio_trigger_id=composio_trigger_id, match_found=False, is_active=row.get("is_active") ) if not matched: logger.error( f"No exact ID match found for Composio trigger {composio_trigger_id}", payload_id=composio_trigger_id, total_triggers=len(rows), matched_count=len(matched) ) return JSONResponse(content={"success": True, "matched_triggers": 0}) trigger_service = get_trigger_service(db) execution_service = get_execution_service(db) executed = 0 for row in matched: trigger_id = row.get("trigger_id") if not trigger_id: continue result = await trigger_service.process_trigger_event(trigger_id, payload) if result.success and result.should_execute_agent: trigger = await trigger_service.get_trigger(trigger_id) if not trigger: continue ctx = { "payload": payload, "trigger_slug": trigger_slug, "webhook_id": wid, } event = TriggerEvent( trigger_id=trigger_id, agent_id=trigger.agent_id, trigger_type=TriggerType.EVENT, raw_data=payload, context=ctx, ) await execution_service.execute_trigger_result( agent_id=trigger.agent_id, trigger_result=result, trigger_event=event, ) executed += 1 return JSONResponse(content={ "success": True, "matched_triggers": len(matched), "executed": executed, }) except HTTPException: raise except Exception as e: logger.error(f"Error handling Composio webhook: {e}") return JSONResponse(status_code=500, content={"success": False, "error": "Internal server error"}) @router.get("/health") async def health_check() -> Dict[str, str]: try: from .client import ComposioClient ComposioClient.get_client() return {"status": "healthy"} except Exception as e: logger.error(f"Health check failed: {e}") raise HTTPException(status_code=503, detail=str(e))