langflow-base-nightly 0.5.0.dev33__py3-none-any.whl → 0.5.0.dev35__py3-none-any.whl

langflow/components/agents/mcp_component.py

@@ -16,14 +16,14 @@ from langflow.base.mcp.util import (
 )
 from langflow.custom.custom_component.component_with_cache import ComponentWithCache
 from langflow.inputs.inputs import InputTypes  # noqa: TC001
-from langflow.io import DropdownInput, McpInput, MessageTextInput, Output
+from langflow.io import DropdownInput, McpInput, MessageTextInput, Output, SecretStrInput
 from langflow.io.schema import flatten_schema, schema_to_langflow_inputs
 from langflow.logging import logger
 from langflow.schema.dataframe import DataFrame
 from langflow.schema.message import Message
-from langflow.services.auth.utils import create_user_longterm_token
 
 # Import get_server from the backend API
+from langflow.services.auth.utils import create_user_longterm_token, get_current_user
 from langflow.services.database.models.user.crud import get_user_by_id
 from langflow.services.deps import get_session, get_settings_service, get_storage_service
 
@@ -96,6 +96,13 @@ class MCPToolsComponent(ComponentWithCache):
             show=False,
             tool_mode=False,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="Langflow API Key",
+            info="Langflow API key for authentication when fetching MCP servers and tools.",
+            required=False,
+            advanced=True,
+        ),
     ]
 
     outputs = [
@@ -155,8 +162,18 @@ class MCPToolsComponent(ComponentWithCache):
 
         try:
             async for db in get_session():
-                user_id, _ = await create_user_longterm_token(db)
-                current_user = await get_user_by_id(db, user_id)
+                # TODO: In 1.6, this may need to be removed or adjusted
+                # Try to get the super user token, if possible
+                if self.api_key:
+                    current_user = await get_current_user(
+                        token=None,
+                        query_param=self.api_key,
+                        header_param=None,
+                        db=db,
+                    )
+                else:
+                    user_id, _ = await create_user_longterm_token(db)
+                    current_user = await get_user_by_id(db, user_id)
 
                 # Try to get server config from DB/API
                 server_config = await get_server(

langflow/components/composio/__init__.py

@@ -9,16 +9,32 @@ if TYPE_CHECKING:
     from .github_composio import ComposioGitHubAPIComponent
     from .gmail_composio import ComposioGmailAPIComponent
     from .googlecalendar_composio import ComposioGoogleCalendarAPIComponent
+    from .googlemeet_composio import ComposioGooglemeetAPIComponent
+    from .googletasks_composio import ComposioGoogleTasksAPIComponent
+    from .linear_composio import ComposioLinearAPIComponent
     from .outlook_composio import ComposioOutlookAPIComponent
+    from .reddit_composio import ComposioRedditAPIComponent
     from .slack_composio import ComposioSlackAPIComponent
+    from .slackbot_composio import ComposioSlackbotAPIComponent
+    from .supabase_composio import ComposioSupabaseAPIComponent
+    from .todoist_composio import ComposioTodoistAPIComponent
+    from .youtube_composio import ComposioYoutubeAPIComponent
 
 _dynamic_imports = {
     "ComposioAPIComponent": "composio_api",
     "ComposioGitHubAPIComponent": "github_composio",
     "ComposioGmailAPIComponent": "gmail_composio",
     "ComposioGoogleCalendarAPIComponent": "googlecalendar_composio",
+    "ComposioGooglemeetAPIComponent": "googlemeet_composio",
     "ComposioOutlookAPIComponent": "outlook_composio",
     "ComposioSlackAPIComponent": "slack_composio",
+    "ComposioGoogleTasksAPIComponent": "googletasks_composio",
+    "ComposioLinearAPIComponent": "linear_composio",
+    "ComposioRedditAPIComponent": "reddit_composio",
+    "ComposioSlackbotAPIComponent": "slackbot_composio",
+    "ComposioSupabaseAPIComponent": "supabase_composio",
+    "ComposioTodoistAPIComponent": "todoist_composio",
+    "ComposioYoutubeAPIComponent": "youtube_composio",
 }
 
 __all__ = [
@@ -26,8 +42,16 @@ __all__ = [
     "ComposioGitHubAPIComponent",
     "ComposioGmailAPIComponent",
     "ComposioGoogleCalendarAPIComponent",
+    "ComposioGoogleTasksAPIComponent",
+    "ComposioGooglemeetAPIComponent",
+    "ComposioLinearAPIComponent",
     "ComposioOutlookAPIComponent",
+    "ComposioRedditAPIComponent",
     "ComposioSlackAPIComponent",
+    "ComposioSlackbotAPIComponent",
+    "ComposioSupabaseAPIComponent",
+    "ComposioTodoistAPIComponent",
+    "ComposioYoutubeAPIComponent",
 ]
 
 

langflow/components/composio/composio_api.py

@@ -2,10 +2,10 @@
 from collections.abc import Sequence
 from typing import Any
 
-from composio import Action, App
+from composio import Composio
+from composio_langchain import LangchainProvider
 
 # Third-party imports
-from composio_langchain import ComposioToolSet
 from langchain_core.tools import Tool
 
 # Local imports
@@ -69,27 +69,7 @@ class ComposioAPIComponent(LCToolComponent):
         Output(name="tools", display_name="Tools", method="build_tool"),
     ]
 
-    def sanitize_action_name(self, action_name: str) -> str:
-        # TODO: Maybe restore
-        return action_name
-
-        # We want to use title case, and replace underscores with spaces
-        sanitized_name = action_name.replace("_", " ").title()
-
-        # Now we want to remove everything from and including the first dot
-        return sanitized_name.replace(self.tool_name.title() + " ", "")
-
-    def desanitize_action_name(self, action_name: str) -> str:
-        # TODO: Maybe restore
-        return action_name
-
-        # We want to reverse what we did above
-        unsanitized_name = action_name.replace(" ", "_").upper()
-
-        # Append the tool_name to it at the beginning, followed by a dot, in all CAPS
-        return f"{self.tool_name.upper()}_{unsanitized_name}"
-
-    def validate_tool(self, build_config: dict, field_value: Any, connected_app_names: list) -> dict:
+    def validate_tool(self, build_config: dict, field_value: Any, tool_name: str | None = None) -> dict:
         # Get the index of the selected tool in the list of options
         selected_tool_index = next(
             (
@@ -108,35 +88,40 @@ class ComposioAPIComponent(LCToolComponent):
         build_config["actions"]["helper_text"] = ""
         build_config["actions"]["helper_text_metadata"] = {"icon": "Check", "variant": "success"}
 
-        # Get the list of actions available
-        all_actions = list(Action.all())
-        authenticated_actions = sorted(
-            [
-                action
-                for action in all_actions
-                if action.app.lower() in list(connected_app_names) and action.app.lower() == self.tool_name.lower()
-            ],
-            key=lambda x: x.name,
-        )
+        try:
+            composio = self._build_wrapper()
+            current_tool = tool_name or getattr(self, "tool_name", None)
+            if not current_tool:
+                self.log("No tool name available for validate_tool")
+                return build_config
+
+            toolkit_slug = current_tool.lower()
+
+            tools = composio.tools.get(user_id=self.entity_id, toolkits=[toolkit_slug])
+
+            authenticated_actions = []
+            for tool in tools:
+                if hasattr(tool, "name"):
+                    action_name = tool.name
+                    display_name = action_name.replace("_", " ").title()
+                    authenticated_actions.append({"name": action_name, "display_name": display_name})
+        except (ValueError, ConnectionError, AttributeError) as e:
+            self.log(f"Error getting actions for {current_tool or 'unknown tool'}: {e}")
+            authenticated_actions = []
 
-        # Return the list of action names
         build_config["actions"]["options"] = [
             {
-                "name": self.sanitize_action_name(action.name),
+                "name": action["name"],
             }
             for action in authenticated_actions
         ]
 
-        # Lastly, we need to show the actions field
         build_config["actions"]["show"] = True
-
         return build_config
 
     def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
-        # If the list of tools is not available, always update it
         if field_name == "api_key" or (self.api_key and not build_config["tool_name"]["options"]):
             if field_name == "api_key" and not field_value:
-                # Reset the list of tools
                 build_config["tool_name"]["options"] = []
                 build_config["tool_name"]["value"] = ""
 
@@ -147,113 +132,94 @@ class ComposioAPIComponent(LCToolComponent):
 
                 return build_config
 
-            # TODO: Re-enable dynamic tool list
-            # Initialize the Composio ToolSet with your API key
-            # toolset = ComposioToolSet(api_key=self.api_key)
-
-            # Get the entity (e.g., "default" for your user)
-            # entity = toolset.get_entity(self.entity_id)
-
-            # Get all available apps
-            # all_apps = entity.client.apps.get()
-
-            # Build an object with name, icon, link
+            # Build the list of available tools
             build_config["tool_name"]["options"] = [
                 {
-                    "name": app.title(),  # TODO: Switch to app.name
-                    "icon": app,  # TODO: Switch to app.name
+                    "name": app.title(),
+                    "icon": app,
                     "link": (
                         build_config["tool_name"]["options"][ind]["link"]
                         if build_config["tool_name"]["options"]
                         else ""
                     ),
                 }
-                # for app in sorted(all_apps, key=lambda x: x.name)
                 for ind, app in enumerate(enabled_tools)
             ]
 
             return build_config
 
-        # Handle the click of the Tool Name connect button
         if field_name == "tool_name" and field_value:
-            # Get the list of apps (tools) we have connected
-            toolset = ComposioToolSet(api_key=self.api_key)
-            connected_apps = [app for app in toolset.get_connected_accounts() if app.status == "ACTIVE"]
-
-            # Get the unique list of appName from the connected apps
-            connected_app_names = [app.appName.lower() for app in connected_apps]
-
-            # Clear out the list of selected actions
-            build_config["actions"]["show"] = True
-            build_config["actions"]["options"] = []
-            build_config["actions"]["value"] = ""
-
-            # Clear out any helper text
-            build_config["tool_name"]["helper_text"] = ""
-            build_config["tool_name"]["helper_text_metadata"] = {}
-
-            # If it's a dictionary, we need to do validation
-            if isinstance(field_value, dict):
-                # If the current field value is a dictionary, it means the user has selected a tool
-                if "validate" not in field_value:
-                    return build_config
-
-                # Check if the selected tool is connected
-                check_app = field_value["validate"].lower()
-
-                # If the tool selected is NOT what we are validating, return the build config
-                if check_app != self.tool_name.lower():
-                    # Set the helper text and helper text metadata field of the actions now
-                    build_config["actions"]["helper_text"] = "Please connect before selecting actions."
-                    build_config["actions"]["helper_text_metadata"] = {
-                        "icon": "OctagonAlert",
-                        "variant": "destructive",
-                    }
-
-                    return build_config
-
-                # Check if the tool is already validated
-                if check_app not in connected_app_names:
-                    return build_config
-
-                # Validate the selected tool
-                return self.validate_tool(build_config, field_value, connected_app_names)
-
-            # Check if the tool is already validated
-            if field_value.lower() in connected_app_names:
-                return self.validate_tool(build_config, field_value, connected_app_names)
-
-            # Get the entity (e.g., "default" for your user)
-            entity = toolset.get_entity(id=self.entity_id)
-
-            # Set the metadata for the actions
-            build_config["actions"]["helper_text_metadata"] = {"icon": "OctagonAlert", "variant": "destructive"}
-
-            # Get the index of the selected tool in the list of options
-            selected_tool_index = next(
-                (ind for ind, tool in enumerate(build_config["tool_name"]["options"]) if tool["name"] == field_value),
-                None,
+            composio = self._build_wrapper()
+
+            current_tool_name = (
+                field_value
+                if isinstance(field_value, str)
+                else field_value.get("validate")
+                if isinstance(field_value, dict) and "validate" in field_value
+                else getattr(self, "tool_name", None)
             )
 
-            # Initiate a GitHub connection and get the redirect URL
-            try:
-                connection_request = entity.initiate_connection(app_name=getattr(App, field_value.upper()))
-            except Exception as _:  # noqa: BLE001
-                # Indicate that there was an error connecting to the tool
-                build_config["tool_name"]["options"][selected_tool_index]["link"] = "error"
-                build_config["tool_name"]["helper_text"] = f"Error connecting to {field_value}"
-                build_config["tool_name"]["helper_text_metadata"] = {
-                    "icon": "OctagonAlert",
-                    "variant": "destructive",
-                }
-
+            if not current_tool_name:
+                self.log("No tool name available for connection check")
                 return build_config
 
-            # Print the direct HTTP link for authentication
-            build_config["tool_name"]["options"][selected_tool_index]["link"] = connection_request.redirectUrl
-
-            # Set the helper text and helper text metadata field of the actions now
-            build_config["actions"]["helper_text"] = "Please connect before selecting actions."
+            try:
+                toolkit_slug = current_tool_name.lower()
+
+                connection_list = composio.connected_accounts.list(
+                    user_ids=[self.entity_id], toolkit_slugs=[toolkit_slug]
+                )
+
+                # Check for active connections
+                has_active_connections = False
+                if (
+                    connection_list
+                    and hasattr(connection_list, "items")
+                    and connection_list.items
+                    and isinstance(connection_list.items, list)
+                    and len(connection_list.items) > 0
+                ):
+                    for connection in connection_list.items:
+                        if getattr(connection, "status", None) == "ACTIVE":
+                            has_active_connections = True
+                            break
+
+                # Get the index of the selected tool in the list of options
+                selected_tool_index = next(
+                    (
+                        ind
+                        for ind, tool in enumerate(build_config["tool_name"]["options"])
+                        if tool["name"] == current_tool_name.title()
+                    ),
+                    None,
+                )
+
+                if has_active_connections:
+                    # User has active connection
+                    if selected_tool_index is not None:
+                        build_config["tool_name"]["options"][selected_tool_index]["link"] = "validated"
+
+                    # If it's a validation request, validate the tool
+                    if (isinstance(field_value, dict) and "validate" in field_value) or isinstance(field_value, str):
+                        return self.validate_tool(build_config, field_value, current_tool_name)
+                else:
+                    # No active connection - create OAuth connection
+                    try:
+                        connection = composio.toolkits.authorize(user_id=self.entity_id, toolkit=toolkit_slug)
+                        redirect_url = getattr(connection, "redirect_url", None)
+
+                        if redirect_url and redirect_url.startswith(("http://", "https://")):
+                            if selected_tool_index is not None:
+                                build_config["tool_name"]["options"][selected_tool_index]["link"] = redirect_url
+                        elif selected_tool_index is not None:
+                            build_config["tool_name"]["options"][selected_tool_index]["link"] = "error"
+                    except (ValueError, ConnectionError, AttributeError) as e:
+                        self.log(f"Error creating OAuth connection: {e}")
+                        if selected_tool_index is not None:
+                            build_config["tool_name"]["options"][selected_tool_index]["link"] = "error"
+
+            except (ValueError, ConnectionError, AttributeError) as e:
+                self.log(f"Error checking connection status: {e}")
 
         return build_config
 
@@ -263,16 +229,30 @@ class ComposioAPIComponent(LCToolComponent):
         Returns:
             Sequence[Tool]: List of configured Composio tools.
         """
-        composio_toolset = self._build_wrapper()
-        return composio_toolset.get_tools(
-            actions=[self.desanitize_action_name(action["name"]) for action in self.actions]
-        )
+        composio = self._build_wrapper()
+        action_names = [action["name"] for action in self.actions]
+
+        # Get toolkits from action names
+        toolkits = set()
+        for action_name in action_names:
+            if "_" in action_name:
+                toolkit = action_name.split("_")[0].lower()
+                toolkits.add(toolkit)
+
+        if not toolkits:
+            return []
+
+        # Get all tools for the relevant toolkits
+        all_tools = composio.tools.get(user_id=self.entity_id, toolkits=list(toolkits))
+
+        # Filter to only the specific actions we want using list comprehension
+        return [tool for tool in all_tools if hasattr(tool, "name") and tool.name in action_names]
 
-    def _build_wrapper(self) -> ComposioToolSet:
-        """Build the Composio toolset wrapper.
+    def _build_wrapper(self) -> Composio:
+        """Build the Composio wrapper using new SDK.
 
         Returns:
-            ComposioToolSet: The initialized toolset.
+            Composio: The initialized Composio client.
 
         Raises:
             ValueError: If the API key is not found or invalid.
@@ -281,7 +261,7 @@ class ComposioAPIComponent(LCToolComponent):
             if not self.api_key:
                 msg = "Composio API Key is required"
                 raise ValueError(msg)
-            return ComposioToolSet(api_key=self.api_key, entity_id=self.entity_id)
+            return Composio(api_key=self.api_key, provider=LangchainProvider())
         except ValueError as e:
             self.log(f"Error building Composio wrapper: {e}")
             msg = "Please provide a valid Composio API Key in the component settings"

langflow/components/composio/dropbox_compnent.py

@@ -0,0 +1,11 @@
+from langflow.base.composio.composio_base import ComposioBaseComponent
+
+
+class ComposioDropboxAPIComponent(ComposioBaseComponent):
+    display_name: str = "Dropbox"
+    icon = "Dropbox"
+    documentation: str = "https://docs.composio.dev"
+    app_name = "dropbox"
+
+    def set_default_tools(self):
+        """Set the default tools for Dropbox component."""