lfx-nightly 0.2.0.dev41__py3-none-any.whl → 0.2.1.dev7__py3-none-any.whl

lfx/components/models_and_agents/language_model.py

@@ -1,43 +1,15 @@
-from typing import Any
-
-import requests
-from langchain_anthropic import ChatAnthropic
-from langchain_ibm import ChatWatsonx
-from langchain_ollama import ChatOllama
-from langchain_openai import ChatOpenAI
-from pydantic.v1 import SecretStr
-
-from lfx.base.models.anthropic_constants import ANTHROPIC_MODELS
-from lfx.base.models.google_generative_ai_constants import GOOGLE_GENERATIVE_AI_MODELS
-from lfx.base.models.google_generative_ai_model import ChatGoogleGenerativeAIFixed
 from lfx.base.models.model import LCModelComponent
-from lfx.base.models.model_utils import get_ollama_models, is_valid_ollama_url
-from lfx.base.models.openai_constants import OPENAI_CHAT_MODEL_NAMES, OPENAI_REASONING_MODEL_NAMES
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_llm,
+    update_model_options_in_build_config,
+)
+from lfx.base.models.watsonx_constants import IBM_WATSONX_URLS
 from lfx.field_typing import LanguageModel
 from lfx.field_typing.range_spec import RangeSpec
-from lfx.inputs.inputs import BoolInput, MessageTextInput, StrInput
-from lfx.io import DropdownInput, MessageInput, MultilineInput, SecretStrInput, SliderInput
-from lfx.log.logger import logger
-from lfx.schema.dotdict import dotdict
-from lfx.utils.util import transform_localhost_url
-
-# IBM watsonx.ai constants
-IBM_WATSONX_DEFAULT_MODELS = ["ibm/granite-3-2b-instruct", "ibm/granite-3-8b-instruct", "ibm/granite-13b-instruct-v2"]
-IBM_WATSONX_URLS = [
-    "https://us-south.ml.cloud.ibm.com",
-    "https://eu-de.ml.cloud.ibm.com",
-    "https://eu-gb.ml.cloud.ibm.com",
-    "https://au-syd.ml.cloud.ibm.com",
-    "https://jp-tok.ml.cloud.ibm.com",
-    "https://ca-tor.ml.cloud.ibm.com",
-]
+from lfx.inputs.inputs import BoolInput, DropdownInput, StrInput
+from lfx.io import MessageInput, ModelInput, MultilineInput, SecretStrInput, SliderInput
 
-# Ollama API constants
-HTTP_STATUS_OK = 200
-JSON_MODELS_KEY = "models"
-JSON_NAME_KEY = "name"
-JSON_CAPABILITIES_KEY = "capabilities"
-DESIRED_CAPABILITY = "completion"
 DEFAULT_OLLAMA_URL = "http://localhost:11434"
 
 
@@ -49,53 +21,22 @@ class LanguageModelComponent(LCModelComponent):
     category = "models"
     priority = 0  # Set priority to 0 to make it appear first
 
-    @staticmethod
-    def fetch_ibm_models(base_url: str) -> list[str]:
-        """Fetch available models from the watsonx.ai API."""
-        try:
-            endpoint = f"{base_url}/ml/v1/foundation_model_specs"
-            params = {"version": "2024-09-16", "filters": "function_text_chat,!lifecycle_withdrawn"}
-            response = requests.get(endpoint, params=params, timeout=10)
-            response.raise_for_status()
-            data = response.json()
-            models = [model["model_id"] for model in data.get("resources", [])]
-            return sorted(models)
-        except Exception:  # noqa: BLE001
-            logger.exception("Error fetching IBM watsonx models. Using default models.")
-            return IBM_WATSONX_DEFAULT_MODELS
-
     inputs = [
-        DropdownInput(
-            name="provider",
-            display_name="Model Provider",
-            options=["OpenAI", "Anthropic", "Google", "IBM watsonx.ai", "Ollama"],
-            value="OpenAI",
-            info="Select the model provider",
+        ModelInput(
+            name="model",
+            display_name="Language Model",
+            info="Select your model provider",
             real_time_refresh=True,
-            options_metadata=[
-                {"icon": "OpenAI"},
-                {"icon": "Anthropic"},
-                {"icon": "GoogleGenerativeAI"},
-                {"icon": "WatsonxAI"},
-                {"icon": "Ollama"},
-            ],
-        ),
-        DropdownInput(
-            name="model_name",
-            display_name="Model Name",
-            options=OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES,
-            value=OPENAI_CHAT_MODEL_NAMES[0],
-            info="Select the model to use",
-            real_time_refresh=True,
-            refresh_button=True,
+            required=True,
         ),
         SecretStrInput(
             name="api_key",
-            display_name="OpenAI API Key",
+            display_name="API Key",
             info="Model Provider API key",
             required=False,
             show=True,
             real_time_refresh=True,
+            advanced=True,
         ),
         DropdownInput(
             name="base_url_ibm_watsonx",
@@ -113,7 +54,7 @@ class LanguageModelComponent(LCModelComponent):
             show=False,
             required=False,
         ),
-        MessageTextInput(
+        MessageInput(
             name="ollama_base_url",
             display_name="Ollama API URL",
             info=f"Endpoint of the Ollama API (Ollama only). Defaults to {DEFAULT_OLLAMA_URL}",
@@ -151,248 +92,43 @@ class LanguageModelComponent(LCModelComponent):
     ]
 
     def build_model(self) -> LanguageModel:
-        provider = self.provider
-        model_name = self.model_name
-        temperature = self.temperature
-        stream = self.stream
-
-        if provider == "OpenAI":
-            if not self.api_key:
-                msg = "OpenAI API key is required when using OpenAI provider"
-                raise ValueError(msg)
-
-            if model_name in OPENAI_REASONING_MODEL_NAMES:
-                # reasoning models do not support temperature (yet)
-                temperature = None
-
-            return ChatOpenAI(
-                model_name=model_name,
-                temperature=temperature,
-                streaming=stream,
-                openai_api_key=self.api_key,
-            )
-        if provider == "Anthropic":
-            if not self.api_key:
-                msg = "Anthropic API key is required when using Anthropic provider"
-                raise ValueError(msg)
-            return ChatAnthropic(
-                model=model_name,
-                temperature=temperature,
-                streaming=stream,
-                anthropic_api_key=self.api_key,
-            )
-        if provider == "Google":
-            if not self.api_key:
-                msg = "Google API key is required when using Google provider"
-                raise ValueError(msg)
-            return ChatGoogleGenerativeAIFixed(
-                model=model_name,
-                temperature=temperature,
-                streaming=stream,
-                google_api_key=self.api_key,
-            )
-        if provider == "IBM watsonx.ai":
-            if not self.api_key:
-                msg = "IBM API key is required when using IBM watsonx.ai provider"
-                raise ValueError(msg)
-            if not self.base_url_ibm_watsonx:
-                msg = "IBM watsonx API Endpoint is required when using IBM watsonx.ai provider"
-                raise ValueError(msg)
-            if not self.project_id:
-                msg = "IBM watsonx Project ID is required when using IBM watsonx.ai provider"
-                raise ValueError(msg)
-            return ChatWatsonx(
-                apikey=SecretStr(self.api_key).get_secret_value(),
-                url=self.base_url_ibm_watsonx,
-                project_id=self.project_id,
-                model_id=model_name,
-                params={
-                    "temperature": temperature,
-                },
-                streaming=stream,
-            )
-        if provider == "Ollama":
-            if not self.ollama_base_url:
-                msg = "Ollama API URL is required when using Ollama provider"
-                raise ValueError(msg)
-            if not model_name:
-                msg = "Model name is required when using Ollama provider"
-                raise ValueError(msg)
-
-            transformed_base_url = transform_localhost_url(self.ollama_base_url)
-
-            # Check if URL contains /v1 suffix (OpenAI-compatible mode)
-            if transformed_base_url and transformed_base_url.rstrip("/").endswith("/v1"):
-                # Strip /v1 suffix and log warning
-                transformed_base_url = transformed_base_url.rstrip("/").removesuffix("/v1")
-                logger.warning(
-                    "Detected '/v1' suffix in base URL. The Ollama component uses the native Ollama API, "
-                    "not the OpenAI-compatible API. The '/v1' suffix has been automatically removed. "
-                    "If you want to use the OpenAI-compatible API, please use the OpenAI component instead. "
-                    "Learn more at https://docs.ollama.com/openai#openai-compatibility"
-                )
-
-            return ChatOllama(
-                base_url=transformed_base_url,
-                model=model_name,
-                temperature=temperature,
-            )
-        msg = f"Unknown provider: {provider}"
-        raise ValueError(msg)
-
-    async def update_build_config(
-        self, build_config: dotdict, field_value: Any, field_name: str | None = None
-    ) -> dotdict:
-        if field_name == "provider":
-            if field_value == "OpenAI":
-                build_config["model_name"]["options"] = OPENAI_CHAT_MODEL_NAMES + OPENAI_REASONING_MODEL_NAMES
-                build_config["model_name"]["value"] = OPENAI_CHAT_MODEL_NAMES[0]
-                build_config["api_key"]["display_name"] = "OpenAI API Key"
-                build_config["api_key"]["show"] = True
-                build_config["base_url_ibm_watsonx"]["show"] = False
-                build_config["project_id"]["show"] = False
-                build_config["ollama_base_url"]["show"] = False
-            elif field_value == "Anthropic":
-                build_config["model_name"]["options"] = ANTHROPIC_MODELS
-                build_config["model_name"]["value"] = ANTHROPIC_MODELS[0]
-                build_config["api_key"]["display_name"] = "Anthropic API Key"
-                build_config["api_key"]["show"] = True
-                build_config["base_url_ibm_watsonx"]["show"] = False
-                build_config["project_id"]["show"] = False
-                build_config["ollama_base_url"]["show"] = False
-            elif field_value == "Google":
-                build_config["model_name"]["options"] = GOOGLE_GENERATIVE_AI_MODELS
-                build_config["model_name"]["value"] = GOOGLE_GENERATIVE_AI_MODELS[0]
-                build_config["api_key"]["display_name"] = "Google API Key"
-                build_config["api_key"]["show"] = True
-                build_config["base_url_ibm_watsonx"]["show"] = False
-                build_config["project_id"]["show"] = False
-                build_config["ollama_base_url"]["show"] = False
-            elif field_value == "IBM watsonx.ai":
-                build_config["model_name"]["options"] = IBM_WATSONX_DEFAULT_MODELS
-                build_config["model_name"]["value"] = IBM_WATSONX_DEFAULT_MODELS[0]
-                build_config["api_key"]["display_name"] = "IBM API Key"
-                build_config["api_key"]["show"] = True
-                build_config["base_url_ibm_watsonx"]["show"] = True
-                build_config["project_id"]["show"] = True
-                build_config["ollama_base_url"]["show"] = False
-            elif field_value == "Ollama":
-                # Fetch Ollama models from the API
-                build_config["api_key"]["show"] = False
-                build_config["base_url_ibm_watsonx"]["show"] = False
-                build_config["project_id"]["show"] = False
-                build_config["ollama_base_url"]["show"] = True
-
-                # Try multiple sources to get the URL (in order of preference):
-                # 1. Instance attribute (already resolved from global/db)
-                # 2. Build config value (may be a global variable reference)
-                # 3. Default value
-                ollama_url = getattr(self, "ollama_base_url", None)
-                if not ollama_url:
-                    config_value = build_config["ollama_base_url"].get("value", DEFAULT_OLLAMA_URL)
-                    # If config_value looks like a variable name (all caps with underscores), use default
-                    is_variable_ref = (
-                        config_value
-                        and isinstance(config_value, str)
-                        and config_value.isupper()
-                        and "_" in config_value
-                    )
-                    if is_variable_ref:
-                        await logger.adebug(
-                            f"Config value appears to be a variable reference: {config_value}, using default"
-                        )
-                        ollama_url = DEFAULT_OLLAMA_URL
-                    else:
-                        ollama_url = config_value
-
-                await logger.adebug(f"Fetching Ollama models for provider switch. URL: {ollama_url}")
-                if await is_valid_ollama_url(url=ollama_url):
-                    try:
-                        models = await get_ollama_models(
-                            base_url_value=ollama_url,
-                            desired_capability=DESIRED_CAPABILITY,
-                            json_models_key=JSON_MODELS_KEY,
-                            json_name_key=JSON_NAME_KEY,
-                            json_capabilities_key=JSON_CAPABILITIES_KEY,
-                        )
-                        build_config["model_name"]["options"] = models
-                        build_config["model_name"]["value"] = models[0] if models else ""
-                    except ValueError:
-                        await logger.awarning("Failed to fetch Ollama models. Setting empty options.")
-                        build_config["model_name"]["options"] = []
-                        build_config["model_name"]["value"] = ""
-                else:
-                    await logger.awarning(f"Invalid Ollama URL: {ollama_url}")
-                    build_config["model_name"]["options"] = []
-                    build_config["model_name"]["value"] = ""
-        elif (
-            field_name == "base_url_ibm_watsonx"
-            and field_value
-            and hasattr(self, "provider")
-            and self.provider == "IBM watsonx.ai"
-        ):
-            # Fetch IBM models when base_url changes
-            try:
-                models = self.fetch_ibm_models(base_url=field_value)
-                build_config["model_name"]["options"] = models
-                build_config["model_name"]["value"] = models[0] if models else IBM_WATSONX_DEFAULT_MODELS[0]
-                info_message = f"Updated model options: {len(models)} models found in {field_value}"
-                logger.info(info_message)
-            except Exception:  # noqa: BLE001
-                logger.exception("Error updating IBM model options.")
-        elif field_name == "ollama_base_url":
-            # Fetch Ollama models when ollama_base_url changes
-            # Use the field_value directly since this is triggered when the field changes
-            logger.debug(
-                f"Fetching Ollama models from updated URL: {build_config['ollama_base_url']} \
-                and value {self.ollama_base_url}",
-            )
-            await logger.adebug(f"Fetching Ollama models from updated URL: {self.ollama_base_url}")
-            if await is_valid_ollama_url(url=self.ollama_base_url):
-                try:
-                    models = await get_ollama_models(
-                        base_url_value=self.ollama_base_url,
-                        desired_capability=DESIRED_CAPABILITY,
-                        json_models_key=JSON_MODELS_KEY,
-                        json_name_key=JSON_NAME_KEY,
-                        json_capabilities_key=JSON_CAPABILITIES_KEY,
-                    )
-                    build_config["model_name"]["options"] = models
-                    build_config["model_name"]["value"] = models[0] if models else ""
-                    info_message = f"Updated model options: {len(models)} models found in {self.ollama_base_url}"
-                    await logger.ainfo(info_message)
-                except ValueError:
-                    await logger.awarning("Error updating Ollama model options.")
-                    build_config["model_name"]["options"] = []
-                    build_config["model_name"]["value"] = ""
-            else:
-                await logger.awarning(f"Invalid Ollama URL: {self.ollama_base_url}")
-                build_config["model_name"]["options"] = []
-                build_config["model_name"]["value"] = ""
-        elif field_name == "model_name":
-            # Refresh Ollama models when model_name field is accessed
-            if hasattr(self, "provider") and self.provider == "Ollama":
-                ollama_url = getattr(self, "ollama_base_url", DEFAULT_OLLAMA_URL)
-                if await is_valid_ollama_url(url=ollama_url):
-                    try:
-                        models = await get_ollama_models(
-                            base_url_value=ollama_url,
-                            desired_capability=DESIRED_CAPABILITY,
-                            json_models_key=JSON_MODELS_KEY,
-                            json_name_key=JSON_NAME_KEY,
-                            json_capabilities_key=JSON_CAPABILITIES_KEY,
-                        )
-                        build_config["model_name"]["options"] = models
-                    except ValueError:
-                        await logger.awarning("Failed to refresh Ollama models.")
-                        build_config["model_name"]["options"] = []
-                else:
-                    build_config["model_name"]["options"] = []
+        return get_llm(
+            model=self.model,
+            user_id=self.user_id,
+            api_key=self.api_key,
+            temperature=self.temperature,
+            stream=self.stream,
+            watsonx_url=getattr(self, "base_url_ibm_watsonx", None),
+            watsonx_project_id=getattr(self, "project_id", None),
+            ollama_base_url=getattr(self, "ollama_base_url", None),
+        )
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        # Update model options
+        build_config = update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
+        # Show/hide provider-specific fields based on selected model
+        if field_name == "model" and isinstance(field_value, list) and len(field_value) > 0:
+            selected_model = field_value[0]
+            provider = selected_model.get("provider", "")
+
+            # Show/hide watsonx fields
+            is_watsonx = provider == "IBM WatsonX"
+            build_config["base_url_ibm_watsonx"]["show"] = is_watsonx
+            build_config["project_id"]["show"] = is_watsonx
+            build_config["base_url_ibm_watsonx"]["required"] = is_watsonx
+            build_config["project_id"]["required"] = is_watsonx
+
+            # Show/hide Ollama fields
+            is_ollama = provider == "Ollama"
+            build_config["ollama_base_url"]["show"] = is_ollama
 
-            # Hide system_message for o1 models - currently unsupported
-            if field_value and field_value.startswith("o1") and hasattr(self, "provider") and self.provider == "OpenAI":
-                if "system_message" in build_config:
-                    build_config["system_message"]["show"] = False
-            elif "system_message" in build_config:
-                build_config["system_message"]["show"] = True
         return build_config

lfx/components/models_and_agents/mcp_component.py

@@ -23,6 +23,31 @@ from lfx.schema.message import Message
 from lfx.services.deps import get_settings_service, get_storage_service, session_scope
 
 
+def resolve_mcp_config(
+    server_name: str,  # noqa: ARG001
+    server_config_from_value: dict | None,
+    server_config_from_db: dict | None,
+) -> dict | None:
+    """Resolve MCP server config with proper precedence.
+
+    Resolves the configuration for an MCP server with the following precedence:
+    1. Database config (takes priority) - ensures edits are reflected
+    2. Config from value/tweaks (fallback) - allows REST API to provide config for new servers
+
+    Args:
+        server_name: Name of the MCP server
+        server_config_from_value: Config provided via value/tweaks (optional)
+        server_config_from_db: Config from database (optional)
+
+    Returns:
+        Final config to use (DB takes priority, falls back to value)
+        Returns None if no config found in either location
+    """
+    if server_config_from_db:
+        return server_config_from_db
+    return server_config_from_value
+
+
 class MCPToolsComponent(ComponentWithCache):
     schema_inputs: list = []
     tools: list[StructuredTool] = []
@@ -189,6 +214,8 @@ class MCPToolsComponent(ComponentWithCache):
                 return self.tools, {"name": server_name, "config": server_config_from_value}
 
         try:
+            # Try to fetch from database first to ensure we have the latest config
+            # This ensures database updates (like editing a server) take effect
             try:
                 from langflow.api.v2.mcp import get_server
                 from langflow.services.database.models.user.crud import get_user_by_id
@@ -198,6 +225,8 @@ class MCPToolsComponent(ComponentWithCache):
                     "This feature requires the full Langflow installation."
                 )
                 raise ImportError(msg) from e
+
+            server_config_from_db = None
             async with session_scope() as db:
                 if not self.user_id:
                     msg = "User ID is required for fetching MCP tools."
@@ -205,7 +234,7 @@ class MCPToolsComponent(ComponentWithCache):
                 current_user = await get_user_by_id(db, self.user_id)
 
                 # Try to get server config from DB/API
-                server_config = await get_server(
+                server_config_from_db = await get_server(
                     server_name,
                     current_user,
                     db,
@@ -213,9 +242,12 @@ class MCPToolsComponent(ComponentWithCache):
                     settings_service=get_settings_service(),
                 )
 
-            # If get_server returns empty but we have a config, use it
-            if not server_config and server_config_from_value:
-                server_config = server_config_from_value
+            # Resolve config with proper precedence: DB takes priority, falls back to value
+            server_config = resolve_mcp_config(
+                server_name=server_name,
+                server_config_from_value=server_config_from_value,
+                server_config_from_db=server_config_from_db,
+            )
 
             if not server_config:
                 self.tools = []
@@ -268,7 +300,10 @@ class MCPToolsComponent(ComponentWithCache):
         try:
             if field_name == "tool":
                 try:
-                    if len(self.tools) == 0:
+                    # Always refresh tools when cache is disabled, or when tools list is empty
+                    # This ensures database edits are reflected immediately when cache is disabled
+                    use_cache = getattr(self, "use_cache", False)
+                    if len(self.tools) == 0 or not use_cache:
                         try:
                             self.tools, build_config["mcp_server"]["value"] = await self.update_tool_list()
                             build_config["tool"]["options"] = [tool.name for tool in self.tools]
@@ -360,6 +395,14 @@ class MCPToolsComponent(ComponentWithCache):
                         return build_config
                 safe_cache_set(self._shared_component_cache, "last_selected_server", current_server_name)
 
+                # When cache is disabled, clear any cached data for this server
+                # This ensures we always fetch fresh data from the database
+                if not use_cache and current_server_name:
+                    servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+                    if isinstance(servers_cache, dict) and current_server_name in servers_cache:
+                        servers_cache.pop(current_server_name)
+                        safe_cache_set(self._shared_component_cache, "servers", servers_cache)
+
                 # Check if tools are already cached for this server before clearing
                 cached_tools = None
                 if current_server_name and use_cache:
@@ -378,9 +421,10 @@ class MCPToolsComponent(ComponentWithCache):
                                 await logger.awarning(msg)
                                 cached_tools = None
 
-                # Only clear tools if we don't have cached tools for the current server
-                if not cached_tools:
-                    self.tools = []  # Clear previous tools only if no cache
+                # Clear tools when cache is disabled OR when we don't have cached tools
+                # This ensures fresh tools are fetched after database edits
+                if not cached_tools or not use_cache:
+                    self.tools = []  # Clear previous tools to force refresh
 
                 # Clear previous tool inputs if:
                 # 1. Server actually changed
@@ -565,7 +609,12 @@ class MCPToolsComponent(ComponentWithCache):
         if item_dict.get("type") == "text":
             text = item_dict.get("text")
             try:
-                return json.loads(text)
+                parsed = json.loads(text)
+                # Ensure we always return a dictionary for DataFrame compatibility
+                if isinstance(parsed, dict):
+                    return parsed
+                # Wrap non-dict parsed values in a dictionary
+                return {"text": text, "parsed_value": parsed, "type": "text"}  # noqa: TRY300
             except json.JSONDecodeError:
                 return item_dict
         return item_dict

lfx/components/ollama/ollama_embeddings.py

@@ -34,7 +34,8 @@ class OllamaEmbeddingsComponent(LCModelComponent):
         MessageTextInput(
             name="base_url",
             display_name="Ollama Base URL",
-            value="",
+            info="Endpoint of the Ollama API. Defaults to http://localhost:11434.",
+            value="http://localhost:11434",
             required=True,
         ),
     ]

lfx/components/openai/openai_chat_model.py

@@ -98,7 +98,7 @@ class OpenAIModelComponent(LCModelComponent):
         # Handle api_key - it can be string or SecretStr
         api_key_value = None
         if self.api_key:
-            logger.debug(f"API key type: {type(self.api_key)}, value: {self.api_key!r}")
+            logger.debug(f"API key type: {type(self.api_key)}, value: {'***' if self.api_key else None}")
             if isinstance(self.api_key, SecretStr):
                 api_key_value = self.api_key.get_secret_value()
             else:

lfx/components/vllm/__init__.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.vllm.vllm import VllmComponent
+    from lfx.components.vllm.vllm_embeddings import VllmEmbeddingsComponent
+
+_dynamic_imports = {
+    "VllmComponent": "vllm",
+    "VllmEmbeddingsComponent": "vllm_embeddings",
+}
+
+__all__ = [
+    "VllmComponent",
+    "VllmEmbeddingsComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import vLLM 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 (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__)