lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/composio/__init__.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .composio_api import ComposioAPIComponent
+    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",
+}
+
+# Always expose all components - individual failures will be handled on import
+__all__ = [
+    "ComposioAPIComponent",
+    "ComposioGitHubAPIComponent",
+    "ComposioGmailAPIComponent",
+    "ComposioGoogleCalendarAPIComponent",
+    "ComposioGoogleTasksAPIComponent",
+    "ComposioGooglemeetAPIComponent",
+    "ComposioLinearAPIComponent",
+    "ComposioOutlookAPIComponent",
+    "ComposioRedditAPIComponent",
+    "ComposioSlackAPIComponent",
+    "ComposioSlackbotAPIComponent",
+    "ComposioSupabaseAPIComponent",
+    "ComposioTodoistAPIComponent",
+    "ComposioYoutubeAPIComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import composio components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/composio/composio_api.py

@@ -0,0 +1,268 @@
+# Standard library imports
+from collections.abc import Sequence
+from typing import Any
+
+from composio import Composio
+from composio_langchain import LangchainProvider
+
+# Third-party imports
+from langchain_core.tools import Tool
+
+# Local imports
+from lfx.base.langchain_utilities.model import LCToolComponent
+from lfx.inputs.inputs import (
+    ConnectionInput,
+    MessageTextInput,
+    SecretStrInput,
+    SortableListInput,
+)
+from lfx.io import Output
+
+# TODO: We get the list from the API but we need to filter it
+enabled_tools = ["confluence", "discord", "dropbox", "github", "gmail", "linkedin", "notion", "slack", "youtube"]
+
+
+class ComposioAPIComponent(LCToolComponent):
+    display_name: str = "Composio Tools"
+    description: str = "Use Composio toolset to run actions with your agent"
+    name = "ComposioAPI"
+    icon = "Composio"
+    documentation: str = "https://docs.composio.dev"
+
+    inputs = [
+        # Basic configuration inputs
+        MessageTextInput(name="entity_id", display_name="Entity ID", value="default", advanced=True),
+        SecretStrInput(
+            name="api_key",
+            display_name="Composio API Key",
+            required=True,
+            info="Refer to https://docs.composio.dev/faq/api_key/api_key",
+            real_time_refresh=True,
+        ),
+        ConnectionInput(
+            name="tool_name",
+            display_name="Tool Name",
+            placeholder="Select a tool...",
+            button_metadata={"icon": "unplug", "variant": "destructive"},
+            options=[],
+            search_category=[],
+            value="",
+            connection_link="",
+            info="The name of the tool to use",
+            real_time_refresh=True,
+        ),
+        SortableListInput(
+            name="actions",
+            display_name="Actions",
+            placeholder="Select action",
+            helper_text="Please connect before selecting actions.",
+            helper_text_metadata={"icon": "OctagonAlert", "variant": "destructive"},
+            options=[],
+            value="",
+            info="The actions to use",
+            limit=1,
+            show=False,
+        ),
+    ]
+
+    outputs = [
+        Output(name="tools", display_name="Tools", method="build_tool"),
+    ]
+
+    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(
+            (
+                ind
+                for ind, tool in enumerate(build_config["tool_name"]["options"])
+                if tool["name"] == field_value
+                or ("validate" in field_value and tool["name"] == field_value["validate"])
+            ),
+            None,
+        )
+
+        # Set the link to be the text 'validated'
+        build_config["tool_name"]["options"][selected_tool_index]["link"] = "validated"
+
+        # Set the helper text and helper text metadata field of the actions now
+        build_config["actions"]["helper_text"] = ""
+        build_config["actions"]["helper_text_metadata"] = {"icon": "Check", "variant": "success"}
+
+        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 = []
+
+        build_config["actions"]["options"] = [
+            {
+                "name": action["name"],
+            }
+            for action in authenticated_actions
+        ]
+
+        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 field_name == "api_key" or (self.api_key and not build_config["tool_name"]["options"]):
+            if field_name == "api_key" and not field_value:
+                build_config["tool_name"]["options"] = []
+                build_config["tool_name"]["value"] = ""
+
+                # Reset the list of actions
+                build_config["actions"]["show"] = False
+                build_config["actions"]["options"] = []
+                build_config["actions"]["value"] = ""
+
+                return build_config
+
+            # Build the list of available tools
+            build_config["tool_name"]["options"] = [
+                {
+                    "name": app.title(),
+                    "icon": app,
+                    "link": (
+                        build_config["tool_name"]["options"][ind]["link"]
+                        if build_config["tool_name"]["options"]
+                        else ""
+                    ),
+                }
+                for ind, app in enumerate(enabled_tools)
+            ]
+
+            return build_config
+
+        if field_name == "tool_name" and field_value:
+            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)
+            )
+
+            if not current_tool_name:
+                self.log("No tool name available for connection check")
+                return build_config
+
+            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
+
+    def build_tool(self) -> Sequence[Tool]:
+        """Build Composio tools based on selected actions.
+
+        Returns:
+            Sequence[Tool]: List of configured Composio tools.
+        """
+        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) -> Composio:
+        """Build the Composio wrapper using new SDK.
+
+        Returns:
+            Composio: The initialized Composio client.
+
+        Raises:
+            ValueError: If the API key is not found or invalid.
+        """
+        try:
+            if not self.api_key:
+                msg = "Composio API Key is required"
+                raise ValueError(msg)
+            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"
+            raise ValueError(msg) from e

lfx/components/composio/dropbox_compnent.py

@@ -0,0 +1,11 @@
+from lfx.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."""

lfx/components/composio/github_composio.py

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

lfx/components/composio/gmail_composio.py

@@ -0,0 +1,38 @@
+from lfx.base.composio.composio_base import ComposioBaseComponent
+
+
+class ComposioGmailAPIComponent(ComposioBaseComponent):
+    display_name: str = "Gmail"
+    icon = "Google"
+    documentation: str = "https://docs.composio.dev"
+    app_name = "gmail"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.post_processors = {
+            "GMAIL_SEND_EMAIL": self._process_send_email_response,
+            "GMAIL_FETCH_EMAILS": self._process_fetch_emails_response,
+        }
+
+    def _process_send_email_response(self, raw_data):
+        """Post-processor for GMAIL_SEND_EMAIL action."""
+        if isinstance(raw_data, dict):
+            response_data = raw_data.get("response_data", raw_data)
+
+            return {
+                "message_id": response_data.get("id"),
+                "thread_id": response_data.get("threadId"),
+                "label_ids": response_data.get("labelIds", []),
+            }
+        return raw_data
+
+    def _process_fetch_emails_response(self, raw_data):
+        """Post-processor for GMAIL_FETCH_EMAILS action."""
+        if isinstance(raw_data, dict):
+            messages = raw_data.get("messages", [])
+            if messages:
+                return messages
+        return raw_data
+
+    def set_default_tools(self):
+        """Set the default tools for Gmail component."""

lfx/components/composio/googlecalendar_composio.py

@@ -0,0 +1,11 @@
+from lfx.base.composio.composio_base import ComposioBaseComponent
+
+
+class ComposioGoogleCalendarAPIComponent(ComposioBaseComponent):
+    display_name: str = "Google Calendar"
+    icon = "Googlecalendar"
+    documentation: str = "https://docs.composio.dev"
+    app_name = "googlecalendar"
+
+    def set_default_tools(self):
+        """Set the default tools for Google Calendar component."""

lfx/components/composio/googlemeet_composio.py

@@ -0,0 +1,11 @@
+from lfx.base.composio.composio_base import ComposioBaseComponent
+
+
+class ComposioGooglemeetAPIComponent(ComposioBaseComponent):
+    display_name: str = "Google Meet"
+    icon = "Googlemeet"
+    documentation: str = "https://docs.composio.dev"
+    app_name = "googlemeet"
+
+    def set_default_tools(self):
+        """Set the default tools for Google Calendar component."""

lfx/components/composio/googletasks_composio.py

@@ -0,0 +1,8 @@
+from lfx.base.composio.composio_base import ComposioBaseComponent
+
+
+class ComposioGoogleTasksAPIComponent(ComposioBaseComponent):
+    display_name: str = "Google Tasks"
+    icon = "GoogleTasks"
+    documentation: str = "https://docs.composio.dev"
+    app_name = "googletasks"

lfx/components/composio/linear_composio.py

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

lfx/components/composio/outlook_composio.py

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

lfx/components/composio/reddit_composio.py

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