lfx-nightly 0.1.12.dev38__py3-none-any.whl → 0.1.12.dev39__py3-none-any.whl

lfx/base/composio/composio_base.py

@@ -67,6 +67,96 @@ class ComposioBaseComponent(Component):
             auth_tooltip="Please insert a valid Composio API Key.",
             show=False,
         ),
+        # Pre-defined placeholder fields for dynamic auth - will be updated dynamically
+        StrInput(
+            name="client_id",
+            display_name="Client id",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="client_secret",
+            display_name="Client secret",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="verification_token",
+            display_name="Verification Token",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="api_key_field",
+            display_name="API Key",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="token",
+            display_name="Token",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        # Additional common auth fields
+        StrInput(
+            name="access_token",
+            display_name="Access Token",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="refresh_token",
+            display_name="Refresh Token",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="username",
+            display_name="Username",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="password",
+            display_name="Password",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="domain",
+            display_name="Domain",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
+        StrInput(
+            name="base_url",
+            display_name="Base URL",
+            info="",
+            show=False,
+            value="",
+            required=False,
+        ),
         SortableListInput(
             name="action_button",
             display_name="Action",
@@ -761,9 +851,6 @@ class ComposioBaseComponent(Component):
         for inp in lf_inputs:
             if inp.name is not None:
                 inp_dict = inp.to_dict() if hasattr(inp, "to_dict") else inp.__dict__.copy()
-
-                # Do not mutate input_types here; keep original configuration
-
                 inp_dict.setdefault("show", True)  # visible once action selected
                 # Preserve previously entered value if user already filled something
                 if inp.name in build_config:
@@ -925,26 +1012,14 @@ class ComposioBaseComponent(Component):
             return self._toolkit_schema
         try:
             composio = self._build_wrapper()
-            # The SDK typically offers a retrieve by slug; if not present, try a few fallbacks
             app_slug = getattr(self, "app_name", "").lower()
             if not app_slug:
                 return None
             try:
-                schema = composio.toolkits.retrieve(slug=app_slug)
-            except (AttributeError, ValueError, ConnectionError, TypeError):
-                schema = None
-                for method_name, kwargs in (
-                    ("retrieve", {"toolkit_slug": app_slug}),
-                    ("get", {"slug": app_slug}),
-                    ("get", {"toolkit_slug": app_slug}),
-                ):
-                    try:
-                        method = getattr(composio.toolkits, method_name)
-                        schema = method(**kwargs)
-                        if schema:
-                            break
-                    except (AttributeError, ValueError, ConnectionError, TypeError):
-                        continue
+                schema = composio.toolkits.get(slug=app_slug)
+            except (AttributeError, ValueError, ConnectionError, TypeError) as e:
+                logger.debug(f"Could not get toolkit schema for {app_slug}: {e}")
+                return None
             self._toolkit_schema = self._to_plain_dict(schema)
         except (AttributeError, ValueError, ConnectionError, TypeError) as e:
             logger.debug(f"Could not retrieve toolkit schema for {getattr(self, 'app_name', '')}: {e}")
@@ -959,8 +1034,12 @@ class ComposioBaseComponent(Component):
         modes: list[str] = []
         # composio_managed_auth_schemes: list[str]
         managed = schema.get("composio_managed_auth_schemes") or schema.get("composioManagedAuthSchemes") or []
-        if isinstance(managed, list):
-            modes.extend([m for m in managed if isinstance(m, str)])
+        has_managed_schemes = isinstance(managed, list) and len(managed) > 0
+
+        # Add "Composio managed" as first option if there are managed schemes
+        if has_managed_schemes:
+            modes.append("Composio managed")
+
         # auth_config_details: list with entries containing mode
         details = schema.get("auth_config_details") or schema.get("authConfigDetails") or []
         for item in details:
@@ -1014,8 +1093,11 @@ class ComposioBaseComponent(Component):
 
     def _clear_auth_dynamic_fields(self, build_config: dict) -> None:
         for fname in list(self._auth_dynamic_fields):
-            if fname in build_config:
-                build_config.pop(fname, None)
+            if fname in build_config and isinstance(build_config[fname], dict):
+                # Hide and reset instead of removing
+                build_config[fname]["show"] = False
+                build_config[fname]["value"] = ""
+                build_config[fname]["required"] = False
         self._auth_dynamic_fields.clear()
 
     def _add_text_field(
@@ -1028,18 +1110,29 @@ class ComposioBaseComponent(Component):
         required: bool,
         default_value: str | None = None,
     ) -> None:
-        """Add a simple text input (StrInput) for custom auth forms, prefilled with schema defaults when available."""
-        field = StrInput(
-            name=name,
-            display_name=display_name or name.replace("_", " ").title(),
-            info=info or "",
-            required=required,
-            real_time_refresh=True,
-            show=True,
-        ).to_dict()
-        if default_value is not None and default_value != "":
-            field["value"] = default_value
-        build_config[name] = field
+        """Update existing field or add new text input for custom auth forms."""
+        # Check if field already exists in build_config (pre-defined placeholder)
+        if name in build_config:
+            # Update existing field properties
+            build_config[name]["display_name"] = display_name or name.replace("_", " ").title()
+            build_config[name]["info"] = info or ""
+            build_config[name]["required"] = required
+            build_config[name]["show"] = True
+            if default_value is not None and default_value != "":
+                build_config[name]["value"] = default_value
+        else:
+            # Create new field if not pre-defined
+            field = StrInput(
+                name=name,
+                display_name=display_name or name.replace("_", " ").title(),
+                info=info or "",
+                required=required,
+                real_time_refresh=True,
+                show=True,
+            ).to_dict()
+            if default_value is not None and default_value != "":
+                field["value"] = default_value
+            build_config[name] = field
         self._auth_dynamic_fields.add(name)
 
     def _render_custom_auth_fields(self, build_config: dict, schema: dict[str, Any], mode: str) -> None:
@@ -1053,35 +1146,37 @@ class ComposioBaseComponent(Component):
         if not selected:
             return
         fields = selected.get("fields") or {}
-        # a) AuthConfigCreation required fields for OAUTH2 custom
+
+        # Helper function to process fields
+        def process_fields(field_list: list, *, required: bool) -> None:
+            for field in field_list:
+                name = field.get("name")
+                if not name:
+                    continue
+                # Skip Access Token field (bearer_token)
+                if name == "bearer_token":
+                    continue
+                # Skip fields with default values for both required and optional fields
+                default_val = field.get("default")
+                if default_val is not None:
+                    continue
+                disp = field.get("display_name") or field.get("displayName") or name
+                desc = field.get("description")
+                self._add_text_field(build_config, name, disp, desc, required=required, default_value=default_val)
+
+        # a) AuthConfigCreation fields (for custom OAuth2, etc.)
         creation = fields.get("auth_config_creation") or fields.get("authConfigCreation") or {}
-        for req in creation.get("required", []):
-            name = req.get("name")
-            if not name:
-                continue
-            disp = req.get("display_name") or req.get("displayName") or name
-            desc = req.get("description")
-            default_val = req.get("default")
-            self._add_text_field(build_config, name, disp, desc, required=True, default_value=default_val)
-        # Optional auth_config_creation fields intentionally not rendered
-        # b) ConnectedAccountInitiation fields for API_KEY mode
+        # Process required fields
+        process_fields(creation.get("required", []), required=True)
+        # Process optional fields (excluding those with defaults and bearer_token)
+        process_fields(creation.get("optional", []), required=False)
+
+        # b) ConnectedAccountInitiation fields (for API_KEY, etc.)
         initiation = fields.get("connected_account_initiation") or fields.get("connectedAccountInitiation") or {}
-        for req in initiation.get("required", []):
-            name = req.get("name")
-            if not name:
-                continue
-            disp = req.get("display_name") or req.get("displayName") or name
-            desc = req.get("description")
-            default_val = req.get("default")
-            self._add_text_field(build_config, name, disp, desc, required=True, default_value=default_val)
-        for opt in initiation.get("optional", []):
-            name = opt.get("name")
-            if not name:
-                continue
-            disp = opt.get("display_name") or opt.get("displayName") or name
-            desc = opt.get("description")
-            default_val = opt.get("default")
-            self._add_text_field(build_config, name, disp, desc, required=False, default_value=default_val)
+        # Process required fields
+        process_fields(initiation.get("required", []), required=True)
+        # Process optional fields (excluding those with defaults)
+        process_fields(initiation.get("optional", []), required=False)
 
     def _collect_all_auth_field_names(self, schema: dict[str, Any] | None) -> set[str]:
         names: set[str] = set()
@@ -1131,8 +1226,6 @@ class ComposioBaseComponent(Component):
 
     def update_build_config(self, build_config: dict, field_value: Any, field_name: str | None = None) -> dict:
         """Update build config for auth and action selection."""
-        # Avoid normalizing legacy input_types here; rely on upstream fixes
-
         # BULLETPROOF tool_mode checking - check all possible places where tool_mode could be stored
         instance_tool_mode = getattr(self, "tool_mode", False) if hasattr(self, "tool_mode") else False
 
@@ -1189,7 +1282,8 @@ class ComposioBaseComponent(Component):
             try:
                 selected_mode = (build_config.get("auth_mode") or {}).get("value")
                 managed = (schema or {}).get("composio_managed_auth_schemes") or []
-                if selected_mode and not (isinstance(managed, list) and selected_mode in managed):
+                # Don't render custom fields if "Composio managed" is selected
+                if selected_mode and selected_mode != "Composio managed":
                     self._clear_auth_dynamic_fields(build_config)
                     self._render_custom_auth_fields(build_config, schema or {}, selected_mode)
             except (TypeError, ValueError, AttributeError):
@@ -1335,9 +1429,13 @@ class ComposioBaseComponent(Component):
                 build_config["create_auth_config"]["value"] = ""
                 build_config["create_auth_config"]["helper_text"] = ""
                 build_config["create_auth_config"]["options"] = ["create"]
-                if isinstance(managed, list) and mode in managed:
-                    # Managed → no extra fields
+                if mode == "Composio managed":
+                    # Composio managed → no extra fields needed
                     pass
+                elif isinstance(managed, list) and mode in managed:
+                    # This is a specific managed auth scheme (e.g., OAUTH2) but user can still choose custom
+                    # So we should render custom fields for this mode
+                    self._render_custom_auth_fields(build_config, schema, mode)
                 else:
                     # Custom → render only required fields based on the toolkit schema
                     self._render_custom_auth_fields(build_config, schema, mode)
@@ -1373,7 +1471,10 @@ class ComposioBaseComponent(Component):
                             mode = build_config["auth_mode"].get("value")
                         # If no managed default exists (400 Default auth config), require mode selection
                         managed = (schema or {}).get("composio_managed_auth_schemes") or []
-                        if isinstance(managed, list) and "OAUTH2" in managed and (mode is None or mode == "OAUTH2"):
+
+                        # Handle "Composio managed" mode explicitly
+                        if mode == "Composio managed":
+                            # Use Composio managed auth flow
                             redirect_url, connection_id = self._initiate_connection(toolkit_slug)
                             build_config["auth_link"]["value"] = redirect_url
                             logger.info(f"New OAuth URL created for {toolkit_slug}: {redirect_url}")
@@ -1748,11 +1849,7 @@ class ComposioBaseComponent(Component):
                 schema = self._get_toolkit_schema()
                 mode = (build_config.get("auth_mode") or {}).get("value")
                 managed = (schema or {}).get("composio_managed_auth_schemes") or []
-                if (
-                    mode
-                    and not (isinstance(managed, list) and mode in managed)
-                    and not getattr(self, "_auth_dynamic_fields", set())
-                ):
+                if mode and mode != "Composio managed" and not getattr(self, "_auth_dynamic_fields", set()):
                     self._render_custom_auth_fields(build_config, schema or {}, mode)
             except (TypeError, ValueError, AttributeError):
                 pass

lfx/cli/run.py

@@ -1,4 +1,5 @@
 import json
+import re
 import sys
 import tempfile
 from functools import partial
@@ -243,9 +244,12 @@ async def run(
             if "ModuleNotFoundError" in str(e) or "No module named" in str(e):
                 logger.info("This appears to be a missing dependency issue")
                 if "langchain" in str(e).lower():
-                    logger.info(
-                        "Missing LangChain dependency detected. Try: pip install langchain-<provider>",
-                    )
+                    match = re.search(r"langchain_(.*)", str(e).lower())
+                    if match:
+                        module_name = match.group(1)
+                        logger.info(
+                            f"Missing LangChain dependency detected. Try: pip install langchain-{module_name}",
+                        )
             elif "ImportError" in str(e):
                 logger.info("This appears to be an import issue - check component dependencies")
             elif "AttributeError" in str(e):

lfx/components/agents/agent.py

@@ -179,6 +179,7 @@ class AgentComponent(ToolCallingAgentComponent):
 
         # Get memory data
         self.chat_history = await self.get_memory_data()
+        await logger.adebug(f"Retrieved {len(self.chat_history)} chat history messages")
         if isinstance(self.chat_history, Message):
             self.chat_history = [self.chat_history]