vibesurf 0.1.32__py3-none-any.whl → 0.1.34__py3-none-any.whl

vibe_surf/backend/shared_state.py

@@ -12,6 +12,8 @@ import os
 import json
 import platform
 from pathlib import Path
+from composio import Composio
+from composio_langchain import LangchainProvider
 
 # VibeSurf components
 from vibe_surf.agents.vibe_surf_agent import VibeSurfAgent
@@ -35,6 +37,7 @@ vibesurf_tools: Optional[VibeSurfTools] = None
 llm: Optional[BaseChatModel] = None
 db_manager: Optional['DatabaseManager'] = None
 current_llm_profile_name: Optional[str] = None
+composio_instance: Optional[Any] = None  # Global Composio instance
 
 # Environment variables
 workspace_dir: str = ""
@@ -54,7 +57,7 @@ active_task: Optional[Dict[str, Any]] = None
 def get_all_components():
     """Get all components as a dictionary"""
     global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager, current_llm_profile_name
-    global workspace_dir, browser_execution_path, browser_user_data, active_mcp_server, envs
+    global workspace_dir, browser_execution_path, browser_user_data, active_mcp_server, envs, composio_instance
 
     return {
         "vibesurf_agent": vibesurf_agent,
@@ -68,6 +71,7 @@ def get_all_components():
         "active_mcp_server": active_mcp_server,
         "active_task": active_task,
         "current_llm_profile_name": current_llm_profile_name,
+        "composio_instance": composio_instance,
         "envs": envs
     }
 
@@ -75,7 +79,7 @@ def get_all_components():
 def set_components(**kwargs):
     """Update global components"""
     global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager, current_llm_profile_name
-    global workspace_dir, browser_execution_path, browser_user_data, active_mcp_server, envs
+    global workspace_dir, browser_execution_path, browser_user_data, active_mcp_server, envs, composio_instance
 
     if "vibesurf_agent" in kwargs:
         vibesurf_agent = kwargs["vibesurf_agent"]
@@ -98,7 +102,9 @@ def set_components(**kwargs):
     if "envs" in kwargs:
         envs = kwargs["envs"]
     if "current_llm_profile_name" in kwargs:
-        envs = kwargs["current_llm_profile_name"]
+        current_llm_profile_name = kwargs["current_llm_profile_name"]
+    if "composio_instance" in kwargs:
+        composio_instance = kwargs["composio_instance"]
 
 
 async def execute_task_background(
@@ -118,6 +124,9 @@ async def execute_task_background(
 
         # Check if MCP server configuration needs update
         await _check_and_update_mcp_servers(db_session)
+        
+        # Check if Composio tools configuration needs update
+        await _check_and_update_composio_tools(db_session)
 
         # Update active task status to running
         active_task = {
@@ -272,6 +281,55 @@ async def _check_and_update_mcp_servers(db_session):
         logger.error(f"Failed to check and update MCP servers: {e}")
 
 
+async def _check_and_update_composio_tools(db_session):
+    """Check if Composio tools configuration has changed and update tools if needed"""
+    global vibesurf_tools, composio_instance
+
+    try:
+        if not db_session:
+            return
+
+        from .database.queries import ComposioToolkitQueries
+
+        # Get current enabled Composio toolkits from database
+        enabled_toolkits = await ComposioToolkitQueries.get_enabled_toolkits(db_session)
+        
+        # Build toolkit_tools_dict from enabled toolkits
+        current_toolkit_tools = {}
+        for toolkit in enabled_toolkits:
+            if toolkit.tools:
+                try:
+                    tools_data = json.loads(toolkit.tools)
+                    current_toolkit_tools[toolkit.slug] = tools_data
+                except (json.JSONDecodeError, TypeError) as e:
+                    logger.warning(f"Failed to parse tools for toolkit {toolkit.slug}: {e}")
+
+        # Check if Composio tools need to be updated
+        tools_changed = False
+        if vibesurf_tools and vibesurf_tools.composio_client:
+            # Compare current tools with registered tools
+            if vibesurf_tools.composio_client._toolkit_tools != current_toolkit_tools:
+                tools_changed = True
+        elif current_toolkit_tools:
+            # No composio client but we have enabled tools - need to register
+            tools_changed = True
+
+        if tools_changed:
+            logger.info(f"Composio tools configuration changed. Updating tools...")
+            logger.info(f"New toolkit tools: {list(current_toolkit_tools.keys())}")
+
+            # Update Composio tools in vibesurf_tools
+            if vibesurf_tools:
+                await vibesurf_tools.update_composio_tools(
+                    composio_instance=composio_instance,
+                    toolkit_tools_dict=current_toolkit_tools
+                )
+                logger.info("✅ Composio tools configuration updated successfully")
+
+    except Exception as e:
+        logger.error(f"Failed to check and update Composio tools: {e}")
+
+
 async def _build_mcp_server_config(active_profiles) -> Dict[str, Any]:
     """Build MCP server configuration from active profiles"""
     mcp_server_config = {
@@ -313,17 +371,54 @@ async def _load_active_mcp_servers():
             except Exception as e:
                 logger.warning(f"Failed to load MCP servers from database: {e}")
                 return {"mcpServers": {}}
-            finally:
-                break
 
     except Exception as e:
         logger.warning(f"Database not available for MCP server loading: {e}")
         return {"mcpServers": {}}
 
 
+async def _load_enabled_composio_toolkits():
+    """Load enabled Composio toolkits from database and return toolkit_tools_dict"""
+    global db_manager
+
+    try:
+        if not db_manager:
+            logger.info("Database manager not available, returning empty Composio config")
+            return {}
+
+        from .database.queries import ComposioToolkitQueries
+
+        async for db in db_manager.get_session():
+            try:
+                # Get all enabled Composio toolkits
+                enabled_toolkits = await ComposioToolkitQueries.get_enabled_toolkits(db)
+                
+                # Build toolkit_tools_dict from enabled toolkits
+                toolkit_tools_dict = {}
+                for toolkit in enabled_toolkits:
+                    if toolkit.tools:
+                        try:
+                            tools_data = json.loads(toolkit.tools)
+                            toolkit_tools_dict[toolkit.slug] = tools_data
+                        except (json.JSONDecodeError, TypeError) as e:
+                            logger.warning(f"Failed to parse tools for toolkit {toolkit.slug}: {e}")
+
+                logger.info(f"✅ Loaded {len(toolkit_tools_dict)} enabled Composio toolkits: {list(toolkit_tools_dict.keys())}")
+
+                return toolkit_tools_dict
+
+            except Exception as e:
+                logger.warning(f"Failed to load Composio toolkits from database: {e}")
+                return {}
+
+    except Exception as e:
+        logger.warning(f"Database not available for Composio toolkit loading: {e}")
+        return {}
+
+
 async def initialize_vibesurf_components():
     """Initialize VibeSurf components from environment variables and default LLM profile"""
-    global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager, current_llm_profile_name
+    global vibesurf_agent, browser_manager, vibesurf_tools, llm, db_manager, current_llm_profile_name, composio_instance
     global workspace_dir, browser_execution_path, browser_user_data, envs
     from vibe_surf import common
 
@@ -447,6 +542,28 @@ async def initialize_vibesurf_components():
             await vibesurf_tools.register_mcp_clients()
             logger.info(f"✅ Registered {len(mcp_server_config['mcpServers'])} MCP servers")
 
+        # Load and register Composio tools from enabled toolkits
+        from .api.composio import _get_composio_api_key_from_db
+        api_key = await _get_composio_api_key_from_db()
+        if api_key:
+            try:
+                # Create Composio instance
+                composio_instance = Composio(
+                    api_key=api_key,
+                    provider=LangchainProvider()
+                )
+                logger.info("Successfully create Composio instance!")
+            except Exception as e:
+                logger.error(f"Failed to create Composio instance: {e}")
+                composio_instance = None
+        toolkit_tools_dict = await _load_enabled_composio_toolkits()
+        if toolkit_tools_dict:
+            await vibesurf_tools.register_composio_clients(
+                composio_instance=composio_instance,
+                toolkit_tools_dict=toolkit_tools_dict
+            )
+            logger.info(f"✅ Registered Composio tools from {len(toolkit_tools_dict)} enabled toolkits")
+
         # Initialize VibeSurfAgent
         vibesurf_agent = VibeSurfAgent(
             llm=llm,
@@ -544,8 +661,6 @@ async def update_llm_from_profile(profile_name: str):
             except Exception as e:
                 logger.error(f"Failed to update LLM from profile {profile_name}: {e}")
                 raise
-            finally:
-                break
 
     except Exception as e:
         logger.error(f"Database error while updating LLM profile: {e}")
@@ -591,7 +706,6 @@ def _update_extension_backend_url(extension_path: str, backend_url: str):
         with open(config_js_path, 'r', encoding='utf-8') as f:
             content = f.read()
 
-        # 匹配 BACKEND_URL: 'xyz' 或 BACKEND_URL: "xyz"，xyz是任意内容
         pattern = r"BACKEND_URL:\s*(['\"]).*?\1"
         replacement = f"BACKEND_URL: '{backend_url}'"
 

vibe_surf/chrome_extension/scripts/api-client.js

@@ -541,6 +541,38 @@ class VibeSurfAPIClient {
       return `${prefix}${timestamp}_${random}`;
     }
   }
+
+  // Composio APIs
+  async verifyComposioKey(apiKey) {
+    return this.post('/composio/verify-key', { api_key: apiKey });
+  }
+
+  async getComposioToolkits(params = {}) {
+    return this.get('/composio/toolkits', { params });
+  }
+
+  async toggleComposioToolkit(slug, enabled) {
+    return this.post(`/composio/toolkit/${encodeURIComponent(slug)}/toggle`, { enabled });
+  }
+
+  async getComposioToolkitTools(slug) {
+    return this.get(`/composio/toolkit/${encodeURIComponent(slug)}/tools`);
+  }
+
+  async updateComposioToolkitTools(slug, selectedTools) {
+    console.log(`[APIClient] Updating toolkit tools for ${slug}:`, selectedTools);
+    const response = await this.post(`/composio/toolkit/${encodeURIComponent(slug)}/tools`, { selected_tools: selectedTools });
+    console.log(`[APIClient] Update toolkit tools response:`, response);
+    return response;
+  }
+
+  async getComposioToolkitConnectionStatus(slug) {
+    return this.get(`/composio/toolkit/${encodeURIComponent(slug)}/connection-status`);
+  }
+
+  async getComposioStatus() {
+    return this.get('/composio/status');
+  }
 }
 
 // Custom error class for API errors