lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/base/composio/composio_base.py

@@ -28,6 +28,12 @@ from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 from lfx.schema.message import Message
+from lfx.utils.validate_cloud import raise_error_if_astra_cloud_disable_component
+
+disable_component_in_astra_cloud_msg = (
+    "Composio tools are not supported in Astra cloud environment. "
+    "Please use local storage mode or cloud-based versions of the tools."
+)
 
 
 class ComposioBaseComponent(Component):
@@ -135,7 +141,7 @@ class ComposioBaseComponent(Component):
         SecretStrInput(
             name="generic_api_key",
             display_name="API Key",
-            info="",
+            info="Enter API key on Composio page",
             show=False,
             value="",
             required=False,
@@ -284,6 +290,21 @@ class ComposioBaseComponent(Component):
     # Track all auth field names discovered across all toolkits
     _all_auth_field_names: set[str] = set()
 
+    @classmethod
+    def get_actions_cache(cls) -> dict[str, dict[str, Any]]:
+        """Get the class-level actions cache."""
+        return cls._actions_cache
+
+    @classmethod
+    def get_action_schema_cache(cls) -> dict[str, dict[str, Any]]:
+        """Get the class-level action schema cache."""
+        return cls._action_schema_cache
+
+    @classmethod
+    def get_all_auth_field_names(cls) -> set[str]:
+        """Get all auth field names discovered across toolkits."""
+        return cls._all_auth_field_names
+
     outputs = [
         Output(name="dataFrame", display_name="DataFrame", method="as_dataframe"),
     ]
@@ -313,6 +334,8 @@ class ComposioBaseComponent(Component):
         return Message(text=str(result))
 
     def as_dataframe(self) -> DataFrame:
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         result = self.execute_action()
 
         if isinstance(result, dict):
@@ -356,6 +379,8 @@ class ComposioBaseComponent(Component):
 
     def _build_wrapper(self) -> Composio:
         """Build the Composio wrapper."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         try:
             if not self.api_key:
                 msg = "Composio API Key is required"
@@ -403,11 +428,11 @@ class ComposioBaseComponent(Component):
 
         # Try to load from the class-level cache
         toolkit_slug = self.app_name.lower()
-        if toolkit_slug in self.__class__._actions_cache:
+        if toolkit_slug in self.__class__.get_actions_cache():
             # Deep-copy so that any mutation on this instance does not affect the
             # cached master copy.
-            self._actions_data = copy.deepcopy(self.__class__._actions_cache[toolkit_slug])
-            self._action_schemas = copy.deepcopy(self.__class__._action_schema_cache.get(toolkit_slug, {}))
+            self._actions_data = copy.deepcopy(self.__class__.get_actions_cache()[toolkit_slug])
+            self._action_schemas = copy.deepcopy(self.__class__.get_action_schema_cache().get(toolkit_slug, {}))
             logger.debug(f"Loaded actions for {toolkit_slug} from in-process cache")
             return
 
@@ -455,11 +480,17 @@ class ComposioBaseComponent(Component):
                     if parameters_schema is None:
                         logger.warning(f"Parameters schema is None for action key: {action_key}")
                         # Still add the action but with empty fields
+                        # Extract version information from the tool
+                        version = tool_dict.get("version")
+                        available_versions = tool_dict.get("available_versions", [])
+
                         self._action_schemas[action_key] = tool_dict
                         self._actions_data[action_key] = {
                             "display_name": display_name,
                             "action_fields": [],
                             "file_upload_fields": set(),
+                            "version": version,
+                            "available_versions": available_versions,
                         }
                         continue
 
@@ -473,11 +504,17 @@ class ComposioBaseComponent(Component):
                                 parameters_schema = parameters_schema.__dict__
                             else:
                                 logger.warning(f"Cannot process parameters schema for {action_key}, skipping")
+                                # Extract version information from the tool
+                                version = tool_dict.get("version")
+                                available_versions = tool_dict.get("available_versions", [])
+
                                 self._action_schemas[action_key] = tool_dict
                                 self._actions_data[action_key] = {
                                     "display_name": display_name,
                                     "action_fields": [],
                                     "file_upload_fields": set(),
+                                    "version": version,
+                                    "available_versions": available_versions,
                                 }
                                 continue
 
@@ -516,22 +553,34 @@ class ComposioBaseComponent(Component):
                                         elif field_name in original_descriptions:
                                             field_schema["description"] = original_descriptions[field_name]
                         except (KeyError, TypeError, ValueError):
+                            # Extract version information from the tool
+                            version = tool_dict.get("version")
+                            available_versions = tool_dict.get("available_versions", [])
+
                             self._action_schemas[action_key] = tool_dict
                             self._actions_data[action_key] = {
                                 "display_name": display_name,
                                 "action_fields": [],
                                 "file_upload_fields": set(),
+                                "version": version,
+                                "available_versions": available_versions,
                             }
                             continue
 
                         if flat_schema is None:
                             logger.warning(f"Flat schema is None for action key: {action_key}")
                             # Still add the action but with empty fields so the UI doesn't break
+                            # Extract version information from the tool
+                            version = tool_dict.get("version")
+                            available_versions = tool_dict.get("available_versions", [])
+
                             self._action_schemas[action_key] = tool_dict
                             self._actions_data[action_key] = {
                                 "display_name": display_name,
                                 "action_fields": [],
                                 "file_upload_fields": set(),
+                                "version": version,
+                                "available_versions": available_versions,
                             }
                             continue
 
@@ -604,20 +653,32 @@ class ComposioBaseComponent(Component):
                                     clean_field_name = p_name.replace("[0]", "")
                                     self._bool_variables.add(clean_field_name)
 
+                        # Extract version information from the tool
+                        version = tool_dict.get("version")
+                        available_versions = tool_dict.get("available_versions", [])
+
                         self._action_schemas[action_key] = tool_dict
                         self._actions_data[action_key] = {
                             "display_name": display_name,
                             "action_fields": action_fields,
                             "file_upload_fields": file_upload_fields,
+                            "version": version,
+                            "available_versions": available_versions,
                         }
 
                     except (KeyError, TypeError, ValueError) as flatten_error:
                         logger.error(f"flatten_schema failed for {action_key}: {flatten_error}")
+                        # Extract version information from the tool
+                        version = tool_dict.get("version")
+                        available_versions = tool_dict.get("available_versions", [])
+
                         self._action_schemas[action_key] = tool_dict
                         self._actions_data[action_key] = {
                             "display_name": display_name,
                             "action_fields": [],
                             "file_upload_fields": set(),
+                            "version": version,
+                            "available_versions": available_versions,
                         }
                         continue
 
@@ -630,8 +691,8 @@ class ComposioBaseComponent(Component):
 
             # Cache actions for this toolkit so subsequent component instances
             # can reuse them without hitting the Composio API again.
-            self.__class__._actions_cache[toolkit_slug] = copy.deepcopy(self._actions_data)
-            self.__class__._action_schema_cache[toolkit_slug] = copy.deepcopy(self._action_schemas)
+            self.__class__.get_actions_cache()[toolkit_slug] = copy.deepcopy(self._actions_data)
+            self.__class__.get_action_schema_cache()[toolkit_slug] = copy.deepcopy(self._action_schemas)
 
         except ValueError as e:
             logger.debug(f"Could not populate Composio actions for {self.app_name}: {e}")
@@ -672,6 +733,9 @@ class ComposioBaseComponent(Component):
                 parameters_schema = parameters_schema.copy()  # Don't modify the original
                 parameters_schema["required"] = []
 
+            # Also get top-level required fields from original schema
+            original_required = set(parameters_schema.get("required", []))
+
             try:
                 # Preserve original descriptions before flattening to restore if lost
                 original_descriptions = {}
@@ -895,6 +959,8 @@ class ComposioBaseComponent(Component):
                     if any(getattr(i, "name", None) == top_name for i in processed_inputs):
                         continue
                     top_schema = props_dict.get(top_name, {})
+                    # For MultilineInput fields (complex JSON objects/arrays)
+                    is_required = top_name in original_required
                     processed_inputs.append(
                         MultilineInput(
                             name=top_name,
@@ -902,7 +968,7 @@ class ComposioBaseComponent(Component):
                             info=(
                                 top_schema.get("description") or "Provide JSON for this parameter (object or array)."
                             ),
-                            required=top_name in required_fields_set,
+                            required=is_required,  # Setting original schema
                         )
                     )
 
@@ -992,24 +1058,14 @@ class ComposioBaseComponent(Component):
         return auth_config.id
 
     def _initiate_connection(self, app_name: str) -> tuple[str, str]:
-        """Initiate OAuth connection and return (redirect_url, connection_id)."""
+        """Initiate connection using link method and return (redirect_url, connection_id)."""
         try:
             composio = self._build_wrapper()
 
-            auth_configs = composio.auth_configs.list(toolkit_slug=app_name)
-            if len(auth_configs.items) == 0:
-                auth_config_id = self.create_new_auth_config(app_name)
-            else:
-                auth_config_id = None
-                for auth_config in auth_configs.items:
-                    if auth_config.auth_scheme == "OAUTH2":
-                        auth_config_id = auth_config.id
-
-                auth_config_id = auth_configs.items[0].id
+            # Always create a new auth config (previous behavior)
+            auth_config_id = self.create_new_auth_config(app_name)
 
-            connection_request = composio.connected_accounts.initiate(
-                user_id=self.entity_id, auth_config_id=auth_config_id
-            )
+            connection_request = composio.connected_accounts.link(user_id=self.entity_id, auth_config_id=auth_config_id)
 
             redirect_url = getattr(connection_request, "redirect_url", None)
             connection_id = getattr(connection_request, "id", None)
@@ -1022,12 +1078,12 @@ class ComposioBaseComponent(Component):
                 msg = "No connection ID received from Composio"
                 raise ValueError(msg)
 
-            logger.info(f"OAuth connection initiated for {app_name}: {redirect_url} (ID: {connection_id})")
+            logger.info(f"Connection initiated for {app_name}: {redirect_url} (ID: {connection_id})")
             return redirect_url, connection_id  # noqa: TRY300
 
         except (ValueError, ConnectionError, TypeError, AttributeError) as e:
             logger.error(f"Error initiating connection for {app_name}: {e}")
-            msg = f"Failed to initiate OAuth connection: {e}"
+            msg = f"Failed to initiate connection: {e}"
             raise ValueError(msg) from e
 
     def _check_connection_status_by_id(self, connection_id: str) -> str | None:
@@ -1313,7 +1369,7 @@ class ComposioBaseComponent(Component):
 
         self._auth_dynamic_fields.add(name)
         # Also add to class-level cache for better tracking
-        self.__class__._all_auth_field_names.add(name)
+        self.__class__.get_all_auth_field_names().add(name)
 
     def _render_custom_auth_fields(self, build_config: dict, schema: dict[str, Any], mode: str) -> None:
         """Render fields for custom auth based on schema auth_config_details sections."""
@@ -1344,20 +1400,14 @@ class ComposioBaseComponent(Component):
                 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.)
+        # Only process AuthConfigCreation fields (for custom OAuth2, etc.)
+        # Connection initiation fields are now handled on Composio page via link method
         creation = fields.get("auth_config_creation") or fields.get("authConfigCreation") or {}
         # 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 {}
-        # 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()
         if not schema:
@@ -1378,7 +1428,7 @@ class ComposioBaseComponent(Component):
                         if name:
                             names.add(name)
                             # Add to class-level cache for tracking all discovered auth fields
-                            self.__class__._all_auth_field_names.add(name)
+                            self.__class__.get_all_auth_field_names().add(name)
         # Only use names discovered from the toolkit schema; do not add aliases
         return names
 
@@ -1443,7 +1493,7 @@ class ComposioBaseComponent(Component):
         # Check if we need to populate actions - but also check cache availability
         actions_available = bool(self._actions_data)
         toolkit_slug = getattr(self, "app_name", "").lower()
-        cached_actions_available = toolkit_slug in self.__class__._actions_cache
+        cached_actions_available = toolkit_slug in self.__class__.get_actions_cache()
 
         should_populate = False
 
@@ -1467,10 +1517,15 @@ class ComposioBaseComponent(Component):
                 selected_mode = (build_config.get("auth_mode") or {}).get("value")
                 managed = (schema or {}).get("composio_managed_auth_schemes") or []
                 # Don't render custom fields if "Composio_Managed" is selected
-                if selected_mode and selected_mode != "Composio_Managed":
+                # For API_KEY and other token modes, no fields are needed as they use link method
+                token_modes = ["API_KEY", "BEARER_TOKEN", "BASIC"]
+                if selected_mode and selected_mode not in ["Composio_Managed", *token_modes]:
                     self._clear_auth_dynamic_fields(build_config)
                     self._render_custom_auth_fields(build_config, schema or {}, selected_mode)
                     # Already reordered in _render_custom_auth_fields
+                elif selected_mode in token_modes:
+                    # Clear any existing auth fields for token-based modes
+                    self._clear_auth_dynamic_fields(build_config)
             except (TypeError, ValueError, AttributeError):
                 pass
 
@@ -1617,6 +1672,9 @@ class ComposioBaseComponent(Component):
                 if mode == "Composio_Managed":
                     # Composio_Managed → no extra fields needed
                     pass
+                elif mode in ["API_KEY", "BEARER_TOKEN", "BASIC"]:
+                    # Token-based modes → no fields needed, user enters on Composio page via link
+                    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
@@ -1681,6 +1739,13 @@ class ComposioBaseComponent(Component):
 
                 # Create new connection ONLY if we truly have no usable connection yet
                 if existing_active is None:
+                    # Check if we already have a redirect URL in progress
+                    current_auth_link_value = build_config.get("auth_link", {}).get("value", "")
+                    if current_auth_link_value and current_auth_link_value.startswith(("http://", "https://")):
+                        # We already have a redirect URL, don't create a new one
+                        logger.info(f"Redirect URL already exists for {toolkit_slug}, skipping new creation")
+                        return self.update_input_types(build_config)
+
                     try:
                         # Determine auth mode
                         schema = self._get_toolkit_schema()
@@ -1703,7 +1768,7 @@ class ComposioBaseComponent(Component):
                             build_config["auth_link"]["auth_tooltip"] = "Select Auth Mode"
                             return self.update_input_types(build_config)
                         # Custom modes: create auth config and/or initiate with config
-                        # Validate required fields before creating any auth config
+                        # Only validate auth_config_creation fields for OAUTH2
                         required_missing = []
                         if mode == "OAUTH2":
                             req_names_pre = self._get_schema_field_names(
@@ -1717,30 +1782,6 @@ class ComposioBaseComponent(Component):
                                     val = build_config[fname].get("value")
                                     if val in (None, ""):
                                         required_missing.append(fname)
-                        elif mode == "API_KEY":
-                            req_names_pre = self._get_schema_field_names(
-                                schema,
-                                "API_KEY",
-                                "connected_account_initiation",
-                                "required",
-                            )
-                            for fname in req_names_pre:
-                                if fname in build_config:
-                                    val = build_config[fname].get("value")
-                                    if val in (None, ""):
-                                        required_missing.append(fname)
-                        else:
-                            req_names_pre = self._get_schema_field_names(
-                                schema,
-                                mode,
-                                "connected_account_initiation",
-                                "required",
-                            )
-                            for fname in req_names_pre:
-                                if fname in build_config:
-                                    val = build_config[fname].get("value")
-                                    if val in (None, ""):
-                                        required_missing.append(fname)
                         if required_missing:
                             # Surface errors on each missing field
                             for fname in required_missing:
@@ -1764,24 +1805,18 @@ class ComposioBaseComponent(Component):
                             # If an auth_config was already created via the button, use it and include initiation fields
                             stored_ac_id = (build_config.get("auth_link") or {}).get("auth_config_id")
                             if stored_ac_id:
-                                # Build val from schema-declared connected_account_initiation required + rendered fields
-                                val_payload = {}
-                                init_req = self._get_schema_field_names(
-                                    schema,
-                                    "OAUTH2",
-                                    "connected_account_initiation",
-                                    "required",
-                                )
-                                candidate_names = set(self._auth_dynamic_fields) | init_req
-                                for fname in candidate_names:
-                                    if fname in build_config:
-                                        v = build_config[fname].get("value")
-                                        if v not in (None, ""):
-                                            val_payload[fname] = v
-                                redirect = composio.connected_accounts.initiate(
+                                # Check if we already have a redirect URL to prevent duplicates
+                                current_link_value = build_config.get("auth_link", {}).get("value", "")
+                                if current_link_value and current_link_value.startswith(("http://", "https://")):
+                                    logger.info(
+                                        f"Redirect URL already exists for {toolkit_slug} OAUTH2, skipping new creation"
+                                    )
+                                    return self.update_input_types(build_config)
+
+                                # Use link method - no need to collect connection initiation fields
+                                redirect = composio.connected_accounts.link(
                                     user_id=self.entity_id,
                                     auth_config_id=stored_ac_id,
-                                    config={"auth_scheme": "OAUTH2", "val": val_payload} if val_payload else None,
                                 )
                                 redirect_url = getattr(redirect, "redirect_url", None)
                                 connection_id = getattr(redirect, "id", None)
@@ -1792,6 +1827,9 @@ class ComposioBaseComponent(Component):
                                 # Clear action blocker text on successful initiation
                                 build_config["action_button"]["helper_text"] = ""
                                 build_config["action_button"]["helper_text_metadata"] = {}
+                                # Clear any auth fields
+                                schema = self._get_toolkit_schema()
+                                self._clear_auth_fields_from_schema(build_config, schema)
                                 return self.update_input_types(build_config)
                             # Otherwise, create custom OAuth2 auth config using schema-declared required fields
                             credentials = {}
@@ -1812,6 +1850,14 @@ class ComposioBaseComponent(Component):
                                     else:
                                         missing.append(fname)
                             # proceed even if missing optional; backend will validate
+                            # Check if we already have a redirect URL to prevent duplicates
+                            current_link_value = build_config.get("auth_link", {}).get("value", "")
+                            if current_link_value and current_link_value.startswith(("http://", "https://")):
+                                logger.info(
+                                    f"Redirect URL already exists for {toolkit_slug} OAUTH2, skipping new creation"
+                                )
+                                return self.update_input_types(build_config)
+
                             ac = composio.auth_configs.create(
                                 toolkit=toolkit_slug,
                                 options={
@@ -1821,30 +1867,8 @@ class ComposioBaseComponent(Component):
                                 },
                             )
                             auth_config_id = getattr(ac, "id", None)
-                            # If the schema declares initiation required fields, render them and defer initiation
-                            init_req = self._get_schema_field_names(
-                                schema,
-                                "OAUTH2",
-                                "connected_account_initiation",
-                                "required",
-                            )
-                            if init_req:
-                                self._clear_auth_dynamic_fields(build_config)
-                                for name in init_req:
-                                    self._add_text_field(
-                                        build_config,
-                                        name=name,
-                                        display_name=name.replace("_", " ").title(),
-                                        info="Provide connection parameter",
-                                        required=True,
-                                    )
-                                build_config.setdefault("auth_link", {})
-                                build_config["auth_link"]["auth_config_id"] = auth_config_id
-                                build_config["auth_link"]["value"] = "connect"
-                                build_config["auth_link"]["auth_tooltip"] = "Connect"
-                                return self.update_input_types(build_config)
-                            # Otherwise initiate immediately
-                            redirect = composio.connected_accounts.initiate(
+                            # Use link method directly - no need to check for connection initiation fields
+                            redirect = composio.connected_accounts.link(
                                 user_id=self.entity_id,
                                 auth_config_id=auth_config_id,
                             )
@@ -1861,141 +1885,64 @@ class ComposioBaseComponent(Component):
                             build_config["action_button"]["helper_text_metadata"] = {}
                             return self.update_input_types(build_config)
                         if mode == "API_KEY":
+                            # Check if we already have a redirect URL to prevent duplicates
+                            current_link_value = build_config.get("auth_link", {}).get("value", "")
+                            if current_link_value and current_link_value.startswith(("http://", "https://")):
+                                logger.info(
+                                    f"Redirect URL already exists for {toolkit_slug} API_KEY, skipping new creation"
+                                )
+                                return self.update_input_types(build_config)
+
                             ac = composio.auth_configs.create(
                                 toolkit=toolkit_slug,
                                 options={"type": "use_custom_auth", "auth_scheme": "API_KEY", "credentials": {}},
                             )
                             auth_config_id = getattr(ac, "id", None)
-                            # Build initiation config.val from schema-declared required names and dynamic fields
-                            val_payload = {}
-                            missing = []
-                            # Collect required names from schema
-                            req_names = self._get_schema_field_names(
-                                schema,
-                                "API_KEY",
-                                "connected_account_initiation",
-                                "required",
-                            )
-                            # Merge rendered dynamic fields and schema-required names
-                            candidate_names = set(self._auth_dynamic_fields) | req_names
-                            for fname in candidate_names:
-                                if fname in build_config:
-                                    val = build_config[fname].get("value")
-                                    if val not in (None, ""):
-                                        val_payload[fname] = val
-                                    else:
-                                        missing.append(fname)
-                            initiation = composio.connected_accounts.initiate(
+                            # Use link method - user will enter API key on Composio page
+                            initiation = composio.connected_accounts.link(
                                 user_id=self.entity_id,
                                 auth_config_id=auth_config_id,
-                                config={"auth_scheme": "API_KEY", "val": val_payload},
                             )
                             connection_id = getattr(initiation, "id", None)
                             redirect_url = getattr(initiation, "redirect_url", None)
-                            # Do not store connection_id on initiation; only when ACTIVE
+                            # API_KEY now also returns redirect URL with new link method
                             if redirect_url:
                                 build_config["auth_link"]["value"] = redirect_url
                                 build_config["auth_link"]["auth_tooltip"] = "Disconnect"
-                            else:
-                                # No redirect for API_KEY; mark as connected
-                                build_config["auth_link"]["value"] = "validated"
-                                build_config["auth_link"]["auth_tooltip"] = "Disconnect"
-                            # In both cases, hide auth fields immediately after successful initiation
+                            # Hide auth fields immediately after successful initiation
                             schema = self._get_toolkit_schema()
                             self._clear_auth_fields_from_schema(build_config, schema)
                             build_config["action_button"]["helper_text"] = ""
                             build_config["action_button"]["helper_text_metadata"] = {}
 
-                            # Convert auth_mode to pill for connected state
-                            if not redirect_url and mode:  # API_KEY or similar direct connection
-                                build_config["auth_link"]["connection_id"] = connection_id
-                                build_config.setdefault("auth_mode", {})
-                                build_config["auth_mode"]["value"] = mode
-                                build_config["auth_mode"]["options"] = [mode]
-                                build_config["auth_mode"]["show"] = False
-                                try:
-                                    pill = TabInput(
-                                        name="auth_mode",
-                                        display_name="Auth Mode",
-                                        options=[mode],
-                                        value=mode,
-                                    ).to_dict()
-                                    pill["show"] = True
-                                    build_config["auth_mode"] = pill
-                                except (TypeError, ValueError, AttributeError):
-                                    build_config["auth_mode"] = {
-                                        "name": "auth_mode",
-                                        "display_name": "Auth Mode",
-                                        "type": "tab",
-                                        "options": [mode],
-                                        "value": mode,
-                                        "show": True,
-                                    }
-
                             return self.update_input_types(build_config)
                         # Generic custom auth flow for any other mode (treat like API_KEY)
+                        # Check if we already have a redirect URL to prevent duplicates
+                        current_link_value = build_config.get("auth_link", {}).get("value", "")
+                        if current_link_value and current_link_value.startswith(("http://", "https://")):
+                            logger.info(f"Redirect URL already exists for {toolkit_slug} {mode}, skipping new creation")
+                            return self.update_input_types(build_config)
+
                         ac = composio.auth_configs.create(
                             toolkit=toolkit_slug,
                             options={"type": "use_custom_auth", "auth_scheme": mode, "credentials": {}},
                         )
                         auth_config_id = getattr(ac, "id", None)
-                        val_payload = {}
-                        req_names = self._get_schema_field_names(
-                            schema,
-                            mode,
-                            "connected_account_initiation",
-                            "required",
-                        )
-                        candidate_names = set(self._auth_dynamic_fields) | req_names
-                        for fname in candidate_names:
-                            if fname in build_config:
-                                val = build_config[fname].get("value")
-                                if val not in (None, ""):
-                                    val_payload[fname] = val
-                        initiation = composio.connected_accounts.initiate(
+                        # Use link method - user will enter required fields on Composio page
+                        initiation = composio.connected_accounts.link(
                             user_id=self.entity_id,
                             auth_config_id=auth_config_id,
-                            config={"auth_scheme": mode, "val": val_payload},
                         )
                         connection_id = getattr(initiation, "id", None)
                         redirect_url = getattr(initiation, "redirect_url", None)
-                        # Do not store connection_id on initiation; only when ACTIVE
                         if redirect_url:
                             build_config["auth_link"]["value"] = redirect_url
                             build_config["auth_link"]["auth_tooltip"] = "Disconnect"
-                        else:
-                            build_config["auth_link"]["value"] = "validated"
-                            build_config["auth_link"]["auth_tooltip"] = "Disconnect"
-                            build_config["auth_link"]["connection_id"] = connection_id
-
-                            # Clear auth fields when connected
-                            schema = self._get_toolkit_schema()
-                            self._clear_auth_fields_from_schema(build_config, schema)
-
-                            # Convert auth_mode to pill for connected state
-                            if mode:
-                                build_config.setdefault("auth_mode", {})
-                                build_config["auth_mode"]["value"] = mode
-                                build_config["auth_mode"]["options"] = [mode]
-                                build_config["auth_mode"]["show"] = False
-                                try:
-                                    pill = TabInput(
-                                        name="auth_mode",
-                                        display_name="Auth Mode",
-                                        options=[mode],
-                                        value=mode,
-                                    ).to_dict()
-                                    pill["show"] = True
-                                    build_config["auth_mode"] = pill
-                                except (TypeError, ValueError, AttributeError):
-                                    build_config["auth_mode"] = {
-                                        "name": "auth_mode",
-                                        "display_name": "Auth Mode",
-                                        "type": "tab",
-                                        "options": [mode],
-                                        "value": mode,
-                                        "show": True,
-                                    }
+                        # Clear auth fields
+                        schema = self._get_toolkit_schema()
+                        self._clear_auth_fields_from_schema(build_config, schema)
+                        build_config["action_button"]["helper_text"] = ""
+                        build_config["action_button"]["helper_text_metadata"] = {}
                         return self.update_input_types(build_config)
                     except (ValueError, ConnectionError, TypeError) as e:
                         logger.error(f"Error creating connection: {e}")
@@ -2129,7 +2076,12 @@ 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 mode != "Composio_Managed" and not getattr(self, "_auth_dynamic_fields", set()):
+                    token_modes = ["API_KEY", "BEARER_TOKEN", "BASIC"]
+                    if (
+                        mode
+                        and mode not in ["Composio_Managed", *token_modes]
+                        and not getattr(self, "_auth_dynamic_fields", set())
+                    ):
                         self._render_custom_auth_fields(build_config, schema or {}, mode)
                         # Already reordered in _render_custom_auth_fields
                 except (TypeError, ValueError, AttributeError):
@@ -2174,6 +2126,12 @@ class ComposioBaseComponent(Component):
         # Handle auth config button click
         if field_name == "create_auth_config" and field_value == "create":
             try:
+                # Check if we already have a redirect URL to prevent duplicates
+                current_link_value = build_config.get("auth_link", {}).get("value", "")
+                if current_link_value and current_link_value.startswith(("http://", "https://")):
+                    logger.info("Redirect URL already exists, skipping new auth config creation")
+                    return self.update_input_types(build_config)
+
                 composio = self._build_wrapper()
                 toolkit_slug = self.app_name.lower()
                 schema = self._get_toolkit_schema() or {}
@@ -2194,29 +2152,8 @@ class ComposioBaseComponent(Component):
                 auth_config_id = getattr(ac, "id", None)
                 build_config.setdefault("auth_link", {})
                 if auth_config_id:
-                    # Check if there are connection initiation required fields
-                    initiation_required = self._get_schema_field_names(
-                        schema, "OAUTH2", "connected_account_initiation", "required"
-                    )
-                    if initiation_required:
-                        # Populate those fields dynamically for the user to fill
-                        self._clear_auth_dynamic_fields(build_config)
-                        for name in initiation_required:
-                            # Render as text inputs to collect connection fields
-                            self._add_text_field(
-                                build_config,
-                                name=name,
-                                display_name=name.replace("_", " ").title(),
-                                info="Provide connection parameter",
-                                required=True,
-                            )
-                        # Store the new auth_config_id so pressing Connect will use it
-                        build_config["auth_link"]["auth_config_id"] = auth_config_id
-                        build_config["auth_link"]["value"] = "connect"
-                        build_config["auth_link"]["auth_tooltip"] = "Connect"
-                        return self.update_input_types(build_config)
-                    # If no initiation fields required, initiate immediately
-                    connection_request = composio.connected_accounts.initiate(
+                    # Use link method directly - no need to check for connection initiation fields
+                    connection_request = composio.connected_accounts.link(
                         user_id=self.entity_id, auth_config_id=auth_config_id
                     )
                     redirect_url = getattr(connection_request, "redirect_url", None)
@@ -2423,6 +2360,8 @@ class ComposioBaseComponent(Component):
 
     def execute_action(self):
         """Execute the selected Composio tool."""
+        # Check if we're in Astra cloud environment and raise an error if we are.
+        raise_error_if_astra_cloud_disable_component(disable_component_in_astra_cloud_msg)
         composio = self._build_wrapper()
         self._populate_actions_data()
         self._build_action_maps()
@@ -2492,12 +2431,23 @@ class ComposioBaseComponent(Component):
 
                 arguments[final_field_name] = value
 
-            # Execute using new SDK
-            result = composio.tools.execute(
-                slug=action_key,
-                arguments=arguments,
-                user_id=self.entity_id,
-            )
+            # Get the version from the action data
+            version = self._actions_data.get(action_key, {}).get("version")
+            if version:
+                logger.info(f"Executing {action_key} with version: {version}")
+
+            # Execute using new SDK with version parameter
+            execute_params = {
+                "slug": action_key,
+                "arguments": arguments,
+                "user_id": self.entity_id,
+            }
+
+            # Only add version if it's available
+            if version:
+                execute_params["version"] = version
+
+            result = composio.tools.execute(**execute_params)
 
             if isinstance(result, dict) and "successful" in result:
                 if result["successful"]:
@@ -2623,7 +2573,7 @@ class ComposioBaseComponent(Component):
         # Add all dynamic auth fields to protected set
         protected.update(self._auth_dynamic_fields)
         # Also protect any auth fields discovered across all instances
-        protected.update(self.__class__._all_auth_field_names)
+        protected.update(self.__class__.get_all_auth_field_names())
 
         for key, cfg in list(build_config.items()):
             if key in protected: