lfx-nightly 0.1.13.dev3__py3-none-any.whl → 0.1.13.dev4__py3-none-any.whl

lfx/base/composio/composio_base.py

@@ -284,6 +284,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"),
     ]
@@ -403,11 +418,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
 
@@ -630,8 +645,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}")
@@ -1313,7 +1328,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."""
@@ -1378,7 +1393,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 +1458,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
 
@@ -2623,7 +2638,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:

lfx/base/datastax/astradb_base.py

@@ -14,6 +14,7 @@ from lfx.io import (
     SecretStrInput,
     StrInput,
 )
+from lfx.log.logger import logger
 
 
 class AstraDBBaseComponent(Component):
@@ -364,8 +365,8 @@ class AstraDBBaseComponent(Component):
                     "status": db.status if db.status != "ACTIVE" else None,
                     "org_id": db.org_id if db.org_id else None,
                 }
-            except Exception:  # noqa: BLE001
-                pass
+            except Exception as e:  # noqa: BLE001
+                logger.debug("Failed to get metadata for database %s: %s", db.name, e)
 
         return db_info_dict
 

lfx/base/io/chat.py

@@ -6,8 +6,9 @@ class ChatComponent(Component):
     description = "Use as base for chat components."
 
     def get_properties_from_source_component(self):
-        if hasattr(self, "_vertex") and hasattr(self._vertex, "incoming_edges") and self._vertex.incoming_edges:
-            source_id = self._vertex.incoming_edges[0].source_id
+        vertex = self.get_vertex()
+        if vertex and hasattr(vertex, "incoming_edges") and vertex.incoming_edges:
+            source_id = vertex.incoming_edges[0].source_id
             source_vertex = self.graph.get_vertex(source_id)
             component = source_vertex.custom_component
             source = component.display_name
@@ -15,6 +16,6 @@ class ChatComponent(Component):
             possible_attributes = ["model_name", "model_id", "model"]
             for attribute in possible_attributes:
                 if hasattr(component, attribute) and getattr(component, attribute):
-                    return getattr(component, attribute), icon, source, component._id
-            return source, icon, component.display_name, component._id
+                    return getattr(component, attribute), icon, source, component.get_id()
+            return source, icon, component.display_name, component.get_id()
         return None, None, None, None

lfx/base/mcp/util.py

@@ -85,6 +85,46 @@ ALLOWED_HEADERS = {
 }
 
 
+def create_mcp_http_client_with_ssl_option(
+    headers: dict[str, str] | None = None,
+    timeout: httpx.Timeout | None = None,
+    auth: httpx.Auth | None = None,
+    *,
+    verify_ssl: bool = True,
+) -> httpx.AsyncClient:
+    """Create an httpx AsyncClient with configurable SSL verification.
+
+    This is a custom factory that extends the standard MCP client factory
+    to support disabling SSL verification for self-signed certificates.
+
+    Args:
+        headers: Optional headers to include with all requests.
+        timeout: Request timeout as httpx.Timeout object.
+        auth: Optional authentication handler.
+        verify_ssl: Whether to verify SSL certificates (default: True).
+
+    Returns:
+        Configured httpx.AsyncClient instance.
+    """
+    kwargs: dict[str, Any] = {
+        "follow_redirects": True,
+        "verify": verify_ssl,
+    }
+
+    if timeout is None:
+        kwargs["timeout"] = httpx.Timeout(30.0)
+    else:
+        kwargs["timeout"] = timeout
+
+    if headers is not None:
+        kwargs["headers"] = headers
+
+    if auth is not None:
+        kwargs["auth"] = auth
+
+    return httpx.AsyncClient(**kwargs)
+
+
 def validate_headers(headers: dict[str, str]) -> dict[str, str]:
     """Validate and sanitize HTTP headers according to RFC 7230.
 
@@ -695,7 +735,7 @@ class MCPSessionManager:
 
         Args:
             session_id: Unique identifier for this session
-            connection_params: Connection parameters including URL, headers, timeouts
+            connection_params: Connection parameters including URL, headers, timeouts, verify_ssl
             preferred_transport: If set to "sse", skip Streamable HTTP and go directly to SSE
 
         Returns:
@@ -711,6 +751,19 @@ class MCPSessionManager:
         # Track which transport succeeded
         used_transport: list[str] = []
 
+        # Get verify_ssl option from connection params, default to True
+        verify_ssl = connection_params.get("verify_ssl", True)
+
+        # Create custom httpx client factory with SSL verification option
+        def custom_httpx_factory(
+            headers: dict[str, str] | None = None,
+            timeout: httpx.Timeout | None = None,
+            auth: httpx.Auth | None = None,
+        ) -> httpx.AsyncClient:
+            return create_mcp_http_client_with_ssl_option(
+                headers=headers, timeout=timeout, auth=auth, verify_ssl=verify_ssl
+            )
+
         async def session_task():
             """Background task that keeps the session alive."""
             streamable_error = None
@@ -725,6 +778,7 @@ class MCPSessionManager:
                         url=connection_params["url"],
                         headers=connection_params["headers"],
                         timeout=connection_params["timeout_seconds"],
+                        httpx_client_factory=custom_httpx_factory,
                     ) as (read, write, _):
                         session = ClientSession(read, write)
                         async with session:
@@ -765,6 +819,7 @@ class MCPSessionManager:
                         connection_params["headers"],
                         connection_params["timeout_seconds"],
                         sse_read_timeout,
+                        httpx_client_factory=custom_httpx_factory,
                     ) as (read, write):
                         session = ClientSession(read, write)
                         async with session:
@@ -1216,6 +1271,8 @@ class MCPStreamableHttpClient:
         headers: dict[str, str] | None = None,
         timeout_seconds: int = 30,
         sse_read_timeout_seconds: int = 30,
+        *,
+        verify_ssl: bool = True,
     ) -> list[StructuredTool]:
         """Connect to MCP server using Streamable HTTP transport with SSE fallback (SDK style)."""
         # Validate and sanitize headers early
@@ -1233,12 +1290,13 @@ class MCPStreamableHttpClient:
                 msg = f"Invalid Streamable HTTP or SSE URL ({url}): {error_msg}"
                 raise ValueError(msg)
             # Store connection parameters for later use in run_tool
-            # Include SSE read timeout for fallback
+            # Include SSE read timeout for fallback and SSL verification option
             self._connection_params = {
                 "url": url,
                 "headers": validated_headers,
                 "timeout_seconds": timeout_seconds,
                 "sse_read_timeout_seconds": sse_read_timeout_seconds,
+                "verify_ssl": verify_ssl,
             }
         elif headers:
             self._connection_params["headers"] = validated_headers
@@ -1258,11 +1316,18 @@ class MCPStreamableHttpClient:
         return response.tools
 
     async def connect_to_server(
-        self, url: str, headers: dict[str, str] | None = None, sse_read_timeout_seconds: int = 30
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+        sse_read_timeout_seconds: int = 30,
+        *,
+        verify_ssl: bool = True,
     ) -> list[StructuredTool]:
         """Connect to MCP server using Streamable HTTP with SSE fallback transport (SDK style)."""
         return await asyncio.wait_for(
-            self._connect_to_server(url, headers, sse_read_timeout_seconds=sse_read_timeout_seconds),
+            self._connect_to_server(
+                url, headers, sse_read_timeout_seconds=sse_read_timeout_seconds, verify_ssl=verify_ssl
+            ),
             timeout=get_settings_service().settings.mcp_server_timeout,
         )
 
@@ -1493,7 +1558,8 @@ async def update_tools(
         client = mcp_stdio_client
     elif mode in ["Streamable_HTTP", "SSE"]:
         # Streamable HTTP connection with SSE fallback
-        tools = await mcp_streamable_http_client.connect_to_server(url, headers=headers)
+        verify_ssl = server_config.get("verify_ssl", True)
+        tools = await mcp_streamable_http_client.connect_to_server(url, headers=headers, verify_ssl=verify_ssl)
         client = mcp_streamable_http_client
     else:
         logger.error(f"Invalid MCP server mode for '{server_name}': {mode}")

lfx/cli/commands.py

@@ -43,7 +43,7 @@ def serve_command(
     host: str = typer.Option("127.0.0.1", "--host", "-h", help="Host to bind the server to"),
     port: int = typer.Option(8000, "--port", "-p", help="Port to bind the server to"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show diagnostic output and execution details"),  # noqa: FBT001, FBT003
-    env_file: Path | None = typer.Option(  # noqa: B008
+    env_file: Path | None = typer.Option(
         None,
         "--env-file",
         help="Path to the .env file containing environment variables",

lfx/components/agents/agent.py

@@ -161,7 +161,7 @@ class AgentComponent(ToolCallingAgentComponent):
                 },
             ],
         ),
-        *LCToolsAgentComponent._base_inputs,
+        *LCToolsAgentComponent.get_base_inputs(),
         # removed memory inputs from agent component
         # *memory_inputs,
         BoolInput(

lfx/components/agents/cuga_agent.py

@@ -185,7 +185,7 @@ class CugaComponent(ToolCallingAgentComponent):
                 },
             ],
         ),
-        *LCToolsAgentComponent._base_inputs,
+        *LCToolsAgentComponent.get_base_inputs(),
         BoolInput(
             name="add_current_date_tool",
             display_name="Current Date",

lfx/components/agents/mcp_component.py

@@ -61,6 +61,7 @@ class MCPToolsComponent(ComponentWithCache):
         "mcp_server",
         "tool",
         "use_cache",
+        "verify_ssl",
     ]
 
     display_name = "MCP Tools"
@@ -86,6 +87,16 @@ class MCPToolsComponent(ComponentWithCache):
             value=False,
             advanced=True,
         ),
+        BoolInput(
+            name="verify_ssl",
+            display_name="Verify SSL Certificate",
+            info=(
+                "Enable SSL certificate verification for HTTPS connections. "
+                "Disable only for development/testing with self-signed certificates."
+            ),
+            value=True,
+            advanced=True,
+        ),
         DropdownInput(
             name="tool",
             display_name="Tool",
@@ -210,6 +221,11 @@ class MCPToolsComponent(ComponentWithCache):
                 self.tools = []
                 return [], {"name": server_name, "config": server_config}
 
+            # Add verify_ssl option to server config if not present
+            if "verify_ssl" not in server_config:
+                verify_ssl = getattr(self, "verify_ssl", True)
+                server_config["verify_ssl"] = verify_ssl
+
             _, tool_list, tool_cache = await update_tools(
                 server_name=server_name,
                 server_config=server_config,

lfx/components/amazon/amazon_bedrock_converse.py

@@ -16,7 +16,7 @@ class AmazonBedrockConverseComponent(LCModelComponent):
     beta = True
 
     inputs = [
-        *LCModelComponent._base_inputs,
+        *LCModelComponent.get_base_inputs(),
         DropdownInput(
             name="model_id",
             display_name="Model ID",

lfx/components/apify/apify_actor.py

@@ -92,7 +92,7 @@ class ApifyActorsComponent(Component):
         """Run the Actor and return node output."""
         input_ = json.loads(self.run_input)
         fields = ApifyActorsComponent.parse_dataset_fields(self.dataset_fields) if self.dataset_fields else None
-        res = self._run_actor(self.actor_id, input_, fields=fields)
+        res = self.run_actor(self.actor_id, input_, fields=fields)
         if self.flatten_dataset:
             res = [ApifyActorsComponent.flatten(item) for item in res]
         data = [Data(data=item) for item in res]
@@ -159,7 +159,7 @@ class ApifyActorsComponent(Component):
                 # retrieve if nested, just in case
                 input_dict = input_dict.get("run_input", input_dict)
 
-                res = parent._run_actor(actor_id, input_dict)
+                res = parent.run_actor(actor_id, input_dict)
                 return "\n\n".join([ApifyActorsComponent.dict_to_json_str(item) for item in res])
 
         return ApifyActorRun
@@ -256,7 +256,7 @@ class ApifyActorsComponent(Component):
         valid_chars = string.ascii_letters + string.digits + "_-"
         return "".join(char if char in valid_chars else "_" for char in actor_id)
 
-    def _run_actor(self, actor_id: str, run_input: dict, fields: list[str] | None = None) -> list[dict]:
+    def run_actor(self, actor_id: str, run_input: dict, fields: list[str] | None = None) -> list[dict]:
         """Run an Apify Actor and return the output dataset.
 
         Args:

lfx/components/datastax/astradb_vectorstore.py

@@ -227,7 +227,7 @@ class AstraDBVectorStoreComponent(AstraDBBaseComponent, LCVectorStoreComponent):
                 for provider in providers.reranking_providers.values()
                 for model in provider.models
             ]
-        except (AttributeError, KeyError) as e:
+        except Exception as e:  # noqa: BLE001
             self.log(f"Hybrid search not available: {e}")
             return {
                 "available": False,

lfx/components/mistral/mistral_embeddings.py

@@ -1,4 +1,4 @@
-from langchain_mistralai.embeddings import MistralAIEmbeddings
+from langchain_mistralai import MistralAIEmbeddings
 from pydantic.v1 import SecretStr
 
 from lfx.base.models.model import LCModelComponent

lfx/components/openrouter/openrouter.py

@@ -1,6 +1,3 @@
-from collections import defaultdict
-from typing import Any
-
 import httpx
 from langchain_openai import ChatOpenAI
 from pydantic.v1 import SecretStr
@@ -8,13 +5,7 @@ from pydantic.v1 import SecretStr
 from lfx.base.models.model import LCModelComponent
 from lfx.field_typing import LanguageModel
 from lfx.field_typing.range_spec import RangeSpec
-from lfx.inputs.inputs import (
-    DropdownInput,
-    IntInput,
-    SecretStrInput,
-    SliderInput,
-    StrInput,
-)
+from lfx.inputs.inputs import DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
 
 
 class OpenRouterComponent(LCModelComponent):
@@ -28,36 +19,13 @@ class OpenRouterComponent(LCModelComponent):
 
     inputs = [
         *LCModelComponent.get_base_inputs(),
-        SecretStrInput(
-            name="api_key", display_name="OpenRouter API Key", required=True, info="Your OpenRouter API key"
-        ),
-        StrInput(
-            name="site_url",
-            display_name="Site URL",
-            info="Your site URL for OpenRouter rankings",
-            advanced=True,
-        ),
-        StrInput(
-            name="app_name",
-            display_name="App Name",
-            info="Your app name for OpenRouter rankings",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="provider",
-            display_name="Provider",
-            info="The AI model provider",
-            options=["Loading providers..."],
-            value="Loading providers...",
-            real_time_refresh=True,
-            required=True,
-        ),
+        SecretStrInput(name="api_key", display_name="API Key", required=True),
         DropdownInput(
             name="model_name",
             display_name="Model",
-            info="The model to use for chat completion",
-            options=["Select a provider first"],
-            value="Select a provider first",
+            options=[],
+            value="",
+            refresh_button=True,
             real_time_refresh=True,
             required=True,
         ),
@@ -66,137 +34,71 @@ class OpenRouterComponent(LCModelComponent):
             display_name="Temperature",
             value=0.7,
             range_spec=RangeSpec(min=0, max=2, step=0.01),
-            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
-            advanced=True,
-        ),
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            info="Maximum number of tokens to generate",
             advanced=True,
         ),
+        IntInput(name="max_tokens", display_name="Max Tokens", advanced=True),
+        StrInput(name="site_url", display_name="Site URL", advanced=True),
+        StrInput(name="app_name", display_name="App Name", advanced=True),
     ]
 
-    def fetch_models(self) -> dict[str, list]:
-        """Fetch available models from OpenRouter API and organize them by provider."""
-        url = "https://openrouter.ai/api/v1/models"
-
+    def fetch_models(self) -> list[dict]:
+        """Fetch available models from OpenRouter."""
         try:
-            with httpx.Client() as client:
-                response = client.get(url)
-                response.raise_for_status()
-
-                models_data = response.json().get("data", [])
-                provider_models = defaultdict(list)
-
-                for model in models_data:
-                    model_id = model.get("id", "")
-                    if "/" in model_id:
-                        provider = model_id.split("/")[0].title()
-                        provider_models[provider].append(
-                            {
-                                "id": model_id,
-                                "name": model.get("name", ""),
-                                "description": model.get("description", ""),
-                                "context_length": model.get("context_length", 0),
-                            }
-                        )
-
-                return dict(provider_models)
-
-        except httpx.HTTPError as e:
-            self.log(f"Error fetching models: {e!s}")
-            return {"Error": [{"id": "error", "name": f"Error fetching models: {e!s}"}]}
+            response = httpx.get("https://openrouter.ai/api/v1/models", timeout=10.0)
+            response.raise_for_status()
+            models = response.json().get("data", [])
+            return sorted(
+                [
+                    {
+                        "id": m["id"],
+                        "name": m.get("name", m["id"]),
+                        "context": m.get("context_length", 0),
+                    }
+                    for m in models
+                    if m.get("id")
+                ],
+                key=lambda x: x["name"],
+            )
+        except (httpx.RequestError, httpx.HTTPStatusError) as e:
+            self.log(f"Error fetching models: {e}")
+            return []
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:  # noqa: ARG002
+        """Update model options."""
+        models = self.fetch_models()
+        if models:
+            build_config["model_name"]["options"] = [m["id"] for m in models]
+            build_config["model_name"]["tooltips"] = {m["id"]: f"{m['name']} ({m['context']:,} tokens)" for m in models}
+        else:
+            build_config["model_name"]["options"] = ["Failed to load models"]
+            build_config["model_name"]["value"] = "Failed to load models"
+        return build_config
 
     def build_model(self) -> LanguageModel:
-        """Build and return the OpenRouter language model."""
-        model_not_selected = "Please select a model"
-        api_key_required = "API key is required"
-
-        if not self.model_name or self.model_name == "Select a provider first":
-            raise ValueError(model_not_selected)
-
+        """Build the OpenRouter model."""
         if not self.api_key:
-            raise ValueError(api_key_required)
-
-        api_key = SecretStr(self.api_key).get_secret_value()
+            msg = "API key is required"
+            raise ValueError(msg)
+        if not self.model_name or self.model_name == "Loading...":
+            msg = "Please select a model"
+            raise ValueError(msg)
 
-        # Build base configuration
-        kwargs: dict[str, Any] = {
+        kwargs = {
             "model": self.model_name,
-            "openai_api_key": api_key,
+            "openai_api_key": SecretStr(self.api_key).get_secret_value(),
             "openai_api_base": "https://openrouter.ai/api/v1",
             "temperature": self.temperature if self.temperature is not None else 0.7,
         }
 
-        # Add optional parameters
         if self.max_tokens:
-            kwargs["max_tokens"] = self.max_tokens
+            kwargs["max_tokens"] = int(self.max_tokens)
 
         headers = {}
         if self.site_url:
             headers["HTTP-Referer"] = self.site_url
         if self.app_name:
             headers["X-Title"] = self.app_name
-
         if headers:
             kwargs["default_headers"] = headers
 
-        try:
-            return ChatOpenAI(**kwargs)
-        except (ValueError, httpx.HTTPError) as err:
-            error_msg = f"Failed to build model: {err!s}"
-            self.log(error_msg)
-            raise ValueError(error_msg) from err
-
-    def _get_exception_message(self, e: Exception) -> str | None:
-        """Get a message from an OpenRouter exception.
-
-        Args:
-            e (Exception): The exception to get the message from.
-
-        Returns:
-            str | None: The message from the exception, or None if no specific message can be extracted.
-        """
-        try:
-            from openai import BadRequestError
-
-            if isinstance(e, BadRequestError):
-                message = e.body.get("message")
-                if message:
-                    return message
-        except ImportError:
-            pass
-        return None
-
-    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
-        """Update build configuration based on field updates."""
-        try:
-            if field_name is None or field_name == "provider":
-                provider_models = self.fetch_models()
-                build_config["provider"]["options"] = sorted(provider_models.keys())
-                if build_config["provider"]["value"] not in provider_models:
-                    build_config["provider"]["value"] = build_config["provider"]["options"][0]
-
-            if field_name == "provider" and field_value in self.fetch_models():
-                provider_models = self.fetch_models()
-                models = provider_models[field_value]
-
-                build_config["model_name"]["options"] = [model["id"] for model in models]
-                if models:
-                    build_config["model_name"]["value"] = models[0]["id"]
-
-                tooltips = {
-                    model["id"]: (f"{model['name']}\nContext Length: {model['context_length']}\n{model['description']}")
-                    for model in models
-                }
-                build_config["model_name"]["tooltips"] = tooltips
-
-        except httpx.HTTPError as e:
-            self.log(f"Error updating build config: {e!s}")
-            build_config["provider"]["options"] = ["Error loading providers"]
-            build_config["provider"]["value"] = "Error loading providers"
-            build_config["model_name"]["options"] = ["Error loading models"]
-            build_config["model_name"]["value"] = "Error loading models"
-
-        return build_config
+        return ChatOpenAI(**kwargs)

lfx/custom/custom_component/component.py

@@ -154,7 +154,7 @@ class Component(CustomComponent):
             self.trace_type = "chain"
 
         # Setup inputs and outputs
-        self._reset_all_output_values()
+        self.reset_all_output_values()
         if self.inputs is not None:
             self.map_inputs(self.inputs)
         self.map_outputs()
@@ -330,7 +330,8 @@ class Component(CustomComponent):
     def set_event_manager(self, event_manager: EventManager | None = None) -> None:
         self._event_manager = event_manager
 
-    def _reset_all_output_values(self) -> None:
+    def reset_all_output_values(self) -> None:
+        """Reset all output values to UNDEFINED."""
         if isinstance(self._outputs_map, dict):
             for output in self._outputs_map.values():
                 output.value = UNDEFINED