option to delete credential profile

Author: Soumyadas15

backend/composio_integration/api.py

@@ -10,7 +10,7 @@
 from .composio_service import (
     get_integration_service,
 )
-from .toolkit_service import ToolkitService
+from .toolkit_service import ToolkitService, ToolsListResponse
 from .composio_profile_service import ComposioProfileService, ComposioProfile
 
 router = APIRouter(prefix="/composio", tags=["composio"])
@@ -21,15 +21,13 @@ def initialize(database: DBConnection):
     global db
     db = database
 
-
 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
@@ -40,7 +38,6 @@ class IntegrationStatusResponse(BaseModel):
     profile_id: Optional[str] = None
     redirect_url: Optional[str] = None
 
-
 class CreateProfileRequest(BaseModel):
     toolkit_slug: str
     profile_name: str
@@ -49,6 +46,10 @@ class CreateProfileRequest(BaseModel):
     is_default: bool = False
     initiation_fields: Optional[Dict[str, str]] = None
 
+class ToolsListRequest(BaseModel):
+    toolkit_slug: str
+    limit: int = 50
+    cursor: Optional[str] = None
 
 class ProfileResponse(BaseModel):
     profile_id: str
@@ -406,6 +407,35 @@ async def get_toolkit_icon(
         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(get_current_user_id_from_jwt)
+):
+    try:
+        logger.info(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("/health")
 async def health_check() -> Dict[str, str]:
     try:

backend/composio_integration/toolkit_service.py

@@ -48,6 +48,31 @@ class DetailedToolkitInfo(BaseModel):
     base_url: Optional[str] = None
 
 
+class ParameterSchema(BaseModel):
+    properties: Dict[str, Any] = {}
+    required: Optional[List[str]] = None
+
+
+class ToolInfo(BaseModel):
+    slug: str
+    name: str
+    description: str
+    version: str
+    input_parameters: ParameterSchema = ParameterSchema()
+    output_parameters: ParameterSchema = ParameterSchema()
+    scopes: List[str] = []
+    tags: List[str] = []
+    no_auth: bool = False
+
+
+class ToolsListResponse(BaseModel):
+    items: List[ToolInfo]
+    next_cursor: Optional[str] = None
+    total_items: int
+    current_page: int = 1
+    total_pages: int = 1
+
+
 class ToolkitService:
     def __init__(self, api_key: Optional[str] = None):
         self.client = ComposioClient.get_client(api_key)
@@ -388,4 +413,80 @@ async def get_detailed_toolkit_info(self, toolkit_slug: str) -> Optional[Detaile
 
         except Exception as e:
             logger.error(f"Failed to get detailed toolkit info for {toolkit_slug}: {e}", exc_info=True)
-            return None 
+            return None
+
+    async def get_toolkit_tools(self, toolkit_slug: str, limit: int = 50, cursor: Optional[str] = None) -> ToolsListResponse:
+        try:
+            logger.info(f"Fetching tools for toolkit: {toolkit_slug}")
+            
+            params = {
+                "limit": limit,
+                "toolkit_slug": toolkit_slug
+            }
+            
+            if cursor:
+                params["cursor"] = cursor
+            
+            tools_response = self.client.tools.list(**params)
+            
+            if hasattr(tools_response, '__dict__'):
+                response_data = tools_response.__dict__
+            else:
+                response_data = tools_response
+            
+            items = response_data.get('items', [])
+            
+            tools = []
+            for item in items:
+                if hasattr(item, '__dict__'):
+                    tool_data = item.__dict__
+                elif hasattr(item, '_asdict'):
+                    tool_data = item._asdict()
+                else:
+                    tool_data = item
+                
+                input_params_raw = tool_data.get("input_parameters", {})
+                output_params_raw = tool_data.get("output_parameters", {})
+                
+                input_parameters = ParameterSchema()
+                if isinstance(input_params_raw, dict):
+                    input_parameters.properties = input_params_raw.get("properties", input_params_raw)
+                    input_parameters.required = input_params_raw.get("required")
+                
+                output_parameters = ParameterSchema()  
+                if isinstance(output_params_raw, dict):
+                    output_parameters.properties = output_params_raw.get("properties", output_params_raw)
+                    output_parameters.required = output_params_raw.get("required")
+                
+                tool = ToolInfo(
+                    slug=tool_data.get("slug", ""),
+                    name=tool_data.get("name", ""),
+                    description=tool_data.get("description", ""),
+                    version=tool_data.get("version", "1.0.0"),
+                    input_parameters=input_parameters,
+                    output_parameters=output_parameters,
+                    scopes=tool_data.get("scopes", []),
+                    tags=tool_data.get("tags", []),
+                    no_auth=tool_data.get("no_auth", False)
+                )
+                tools.append(tool)
+            
+            result = ToolsListResponse(
+                items=tools,
+                total_items=response_data.get("total_items", len(tools)),
+                total_pages=response_data.get("total_pages", 1),
+                current_page=response_data.get("current_page", 1),
+                next_cursor=response_data.get("next_cursor")
+            )
+            
+            logger.info(f"Successfully fetched {len(tools)} tools for toolkit {toolkit_slug}")
+            return result
+            
+        except Exception as e:
+            logger.error(f"Failed to get tools for toolkit {toolkit_slug}: {e}", exc_info=True)
+            return ToolsListResponse(
+                items=[],
+                total_items=0,
+                current_page=1,
+                total_pages=1
+            ) 

backend/credentials/api.py

@@ -42,6 +42,10 @@ def validate_config_not_empty_field(cls, v):
         return validate_config_not_empty(v)
 
 
+class BulkDeleteProfilesRequest(BaseModel):
+    profile_ids: List[str]
+
+
 class CredentialResponse(BaseModel):
     credential_id: str
     mcp_qualified_name: str
@@ -64,6 +68,13 @@ class CredentialProfileResponse(BaseModel):
     updated_at: Optional[str] = None
 
 
+class BulkDeleteProfilesResponse(BaseModel):
+    success: bool
+    deleted_count: int
+    failed_profiles: List[str] = []
+    message: str
+
+
 class ComposioProfileSummary(BaseModel):
     profile_id: str
     profile_name: str
@@ -355,6 +366,37 @@ async def delete_credential_profile(
         raise HTTPException(status_code=500, detail="Internal server error")
 
 
+@router.post("/credential-profiles/bulk-delete", response_model=BulkDeleteProfilesResponse)
+async def bulk_delete_credential_profiles(
+    request: BulkDeleteProfilesRequest,
+    user_id: str = Depends(get_current_user_id_from_jwt)
+):
+    try:
+        profile_service = get_profile_service(db)
+        deleted_count = 0
+        failed_profiles = []
+        for profile_id in request.profile_ids:
+            try:
+                success = await profile_service.delete_profile(user_id, profile_id)
+                if success:
+                    deleted_count += 1
+                else:
+                    failed_profiles.append(profile_id)
+            except Exception as e:
+                logger.error(f"Error deleting profile {profile_id}: {e}")
+                failed_profiles.append(profile_id)
+        
+        return BulkDeleteProfilesResponse(
+            success=True,
+            deleted_count=deleted_count,
+            failed_profiles=failed_profiles,
+            message="Bulk deletion completed"
+        )
+    except Exception as e:
+        logger.error(f"Error performing bulk deletion: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error")
+
+
 @router.get("/composio-profiles", response_model=ComposioCredentialsResponse)
 async def get_composio_profiles(
     user_id: str = Depends(get_current_user_id_from_jwt)