Download core/composio_integration/api.py from Kyrlos11/nniback: direct link, hf CLI and curl.
- Browser
- Download file 43 kB
-
https://huggingface.co/spaces/Kyrlos11/nniback/resolve/main/core/composio_integration/api.py
- Command line
-
hf download hf://spaces/Kyrlos11/nniback/core/composio_integration/api.py
-
curl -L -o api.py https://huggingface.co/spaces/Kyrlos11/nniback/resolve/main/core/composio_integration/api.py
43 kB
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))
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")