Merge pull request #1241 from escapade-mckv/ui-polishing

UI polishing

Author: escapade-mckv

backend/composio_integration/api.py

@@ -12,7 +12,7 @@
     ComposioIntegrationService,
     ComposioIntegrationResult
 )
-from .toolkit_service import ToolkitInfo, ToolkitService, CategoryInfo
+from .toolkit_service import ToolkitInfo, ToolkitService, CategoryInfo, DetailedToolkitInfo
 from .composio_profile_service import ComposioProfileService, ComposioProfile
 
 router = APIRouter(prefix="/composio", tags=["composio"])
@@ -49,6 +49,7 @@ class CreateProfileRequest(BaseModel):
     display_name: Optional[str] = None
     mcp_server_name: Optional[str] = None
     is_default: bool = False
+    initiation_fields: Optional[Dict[str, str]] = None
 
 
 class ProfileResponse(BaseModel):
@@ -103,31 +104,62 @@ async def list_categories(
 @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(get_current_user_id_from_jwt)
 ) -> Dict[str, Any]:
     try:
-        logger.info(f"Fetching Composio toolkits with limit: {limit}, search: {search}, category: {category}")
+        logger.info(f"Fetching Composio toolkits with limit: {limit}, cursor: {cursor}, search: {search}, category: {category}")
 
         service = get_integration_service()
 
         if search:
-            toolkits = await service.search_toolkits(search, category=category)
+            result = await service.search_toolkits(search, category=category, limit=limit, cursor=cursor)
         else:
-            toolkits = await service.list_available_toolkits(limit, category=category)
+            result = await service.list_available_toolkits(limit, cursor=cursor, category=category)
 
         return {
             "success": True,
-            "toolkits": [toolkit.dict() for toolkit in toolkits],
-            "total": len(toolkits)
+            "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(get_current_user_id_from_jwt)
+) -> Dict[str, Any]:
+    try:
+        logger.info(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,
@@ -182,7 +214,8 @@ async def create_profile(
             profile_name=request.profile_name,
             display_name=request.display_name,
             mcp_server_name=request.mcp_server_name,
-            save_as_profile=True
+            save_as_profile=True,
+            initiation_fields=request.initiation_fields
         )
 
         logger.info(f"Integration result for {request.toolkit_slug}: redirect_url = {result.connected_account.redirect_url}")

backend/composio_integration/auth_config_service.py

@@ -1,4 +1,4 @@
-from typing import Optional, List
+from typing import Optional, List, Dict, Any, Union
 from composio_client import Composio
 from utils.logger import logger
 from pydantic import BaseModel
@@ -18,15 +18,51 @@ class AuthConfigService:
     def __init__(self, api_key: Optional[str] = None):
         self.client = ComposioClient.get_client(api_key)
 
-    async def create_auth_config(self, toolkit_slug: str) -> AuthConfig:
+    def _convert_field_value(self, value: str, field_type: str) -> Union[str, bool, float]:
+        if field_type == 'boolean':
+            if isinstance(value, bool):
+                return value
+            return value.lower() in ('true', '1', 'yes', 'on')
+        elif field_type == 'number' or field_type == 'double':
+            try:
+                return float(value)
+            except (ValueError, TypeError):
+                logger.warning(f"Failed to convert '{value}' to float, using as string")
+                return str(value)
+        else:
+            return str(value)
+    
+    async def create_auth_config(
+        self, 
+        toolkit_slug: str, 
+        initiation_fields: Optional[Dict[str, str]] = None
+    ) -> AuthConfig:
         try:
             logger.info(f"Creating auth config for toolkit: {toolkit_slug}")
+            logger.info(f"Initiation fields: {initiation_fields}")
+            
+            credentials = {"region": "ind"}
+            
+            if initiation_fields:
+                for field_name, field_value in initiation_fields.items():
+                    if field_value:
+                        if field_name == "suffix.one":
+                            credentials["extension"] = str(field_value)
+                        else:
+                            credentials[field_name] = str(field_value)
+            
+            logger.info(f"Using credentials: {credentials}")
 
             response = self.client.auth_configs.create(
-                toolkit={"slug": toolkit_slug}
+                toolkit={
+                    "slug": toolkit_slug
+                },
+                auth_config={
+                    "type": "use_composio_managed_auth",
+                    "credentials": credentials
+                }
             )
 
-            # Access Pydantic model attributes directly
             auth_config_obj = response.auth_config
 
             auth_config = AuthConfig(
@@ -53,7 +89,6 @@ async def get_auth_config(self, auth_config_id: str) -> Optional[AuthConfig]:
             if not response:
                 return None
 
-            # Access Pydantic model attributes directly
             return AuthConfig(
                 id=response.id,
                 auth_scheme=response.auth_scheme,

backend/composio_integration/composio_service.py

@@ -40,23 +40,29 @@ async def integrate_toolkit(
         profile_name: Optional[str] = None,
         display_name: Optional[str] = None,
         mcp_server_name: Optional[str] = None,
-        save_as_profile: bool = True
+        save_as_profile: bool = True,
+        initiation_fields: Optional[Dict[str, str]] = None
     ) -> ComposioIntegrationResult:
         try:
             logger.info(f"Starting Composio integration for toolkit: {toolkit_slug}")
+            logger.info(f"Initiation fields: {initiation_fields}")
 
             toolkit = await self.toolkit_service.get_toolkit_by_slug(toolkit_slug)
             if not toolkit:
                 raise ValueError(f"Toolkit '{toolkit_slug}' not found")
 
             logger.info(f"Step 1 complete: Verified toolkit {toolkit_slug}")
 
-            auth_config = await self.auth_config_service.create_auth_config(toolkit_slug)
+            auth_config = await self.auth_config_service.create_auth_config(
+                toolkit_slug, 
+                initiation_fields=initiation_fields
+            )
             logger.info(f"Step 2 complete: Created auth config {auth_config.id}")
 
             connected_account = await self.connected_account_service.create_connected_account(
                 auth_config_id=auth_config.id,
-                user_id=user_id
+                user_id=user_id,
+                initiation_fields=initiation_fields
             )
             logger.info(f"Step 3 complete: Connected account {connected_account.id}")
 
@@ -113,11 +119,11 @@ async def integrate_toolkit(
             logger.error(f"Failed to integrate toolkit {toolkit_slug}: {e}", exc_info=True)
             raise
 
-    async def list_available_toolkits(self, limit: int = 100, category: Optional[str] = None) -> List[ToolkitInfo]:
-        return await self.toolkit_service.list_toolkits(limit=limit, category=category)
+    async def list_available_toolkits(self, limit: int = 100, cursor: Optional[str] = None, category: Optional[str] = None) -> Dict[str, Any]:
+        return await self.toolkit_service.list_toolkits(limit=limit, cursor=cursor, category=category)
 
-    async def search_toolkits(self, query: str, category: Optional[str] = None) -> List[ToolkitInfo]:
-        return await self.toolkit_service.search_toolkits(query, category=category)
+    async def search_toolkits(self, query: str, category: Optional[str] = None, limit: int = 100, cursor: Optional[str] = None) -> Dict[str, Any]:
+        return await self.toolkit_service.search_toolkits(query, category=category, limit=limit, cursor=cursor)
 
     async def get_integration_status(self, connected_account_id: str) -> Dict[str, Any]:
         return await self.connected_account_service.get_auth_status(connected_account_id)

backend/composio_integration/connected_account_service.py

@@ -58,20 +58,34 @@ def _extract_val_dict(self, val_obj) -> Dict[str, Any]:
     async def create_connected_account(
         self, 
         auth_config_id: str, 
-        user_id: str
+        user_id: str,
+        initiation_fields: Optional[Dict[str, str]] = None
     ) -> ConnectedAccount:
         try:
             logger.info(f"Creating connected account for auth_config: {auth_config_id}, user: {user_id}")
+            logger.info(f"Initiation fields for connected account: {initiation_fields}")
+            
+            state_val = {"status": "INITIALIZING"}
+            
+            if initiation_fields:
+                for field_name, field_value in initiation_fields.items():
+                    if field_value:
+                        if field_name == "suffix.one":
+                            state_val["extension"] = str(field_value)
+                        else:
+                            state_val[field_name] = str(field_value)
+            
+            logger.info(f"Using state.val: {state_val}")
 
             response = self.client.connected_accounts.create(
-                auth_config={"id": auth_config_id},
+                auth_config={
+                    "id": auth_config_id
+                },
                 connection={
                     "user_id": user_id,
                     "state": {
                         "authScheme": "OAUTH2",
-                        "val": {
-                            "status": "INITIALIZING"
-                        }
+                        "val": state_val,
                     }
                 }
             )