feat: Add full provider variable metadata and multi-variable support

src/backend/base/langflow/api/v1/models.py

@@ -6,6 +6,7 @@
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 from lfx.base.models.unified_models import (
+    get_model_provider_metadata,
     get_model_provider_variable_mapping,
     get_model_providers,
     get_unified_models_detailed,
@@ -186,8 +187,20 @@ def sort_key(provider_dict):
 
 
 @router.get("/provider-variable-mapping", status_code=200)
-async def get_model_provider_mapping() -> dict[str, str]:
-    return get_model_provider_variable_mapping()
+async def get_model_provider_mapping() -> dict[str, list[dict]]:
+    """Return provider variables mapping with full variable info.
+
+    Each provider maps to a list of variable objects containing:
+    - variable_name: Display name shown to user
+    - variable_key: Environment variable key
+    - description: Help text for the variable
+    - required: Whether the variable is required
+    - is_secret: Whether to treat as credential
+    - is_list: Whether it accepts multiple values
+    - options: Predefined options for dropdowns
+    """
+    metadata = get_model_provider_metadata()
+    return {provider: meta.get("variables", []) for provider, meta in metadata.items()}
 
 
 @router.get("/enabled_providers", status_code=200)

src/backend/base/langflow/services/variable/service.py

@@ -32,13 +32,25 @@
 
         # Import the provider mapping to set default_fields for known providers
         try:
-            from lfx.base.models.unified_models import get_model_provider_variable_mapping
+            from lfx.base.models.unified_models import (
+                get_model_provider_metadata,
+                get_model_provider_variable_mapping,
+            )
 
             provider_mapping = get_model_provider_variable_mapping()
-            # Reverse the mapping to go from variable name to provider
-            var_to_provider = {var_name: provider for provider, var_name in provider_mapping.items()}
+            # Build var_to_provider from all variables in metadata (not just primary)
+            var_to_provider = {}
+            var_to_info = {}  # Maps variable_key to its full info (including is_secret)
+            metadata = get_model_provider_metadata()
+            for provider, meta in metadata.items():
+                for var in meta.get("variables", []):
+                    var_key = var.get("variable_key")
+                    if var_key:
+                        var_to_provider[var_key] = provider
+                        var_to_info[var_key] = var
         except Exception:  # noqa: BLE001
             var_to_provider = {}
+            var_to_info = {}
 
         for var_name in self.settings_service.settings.variables_to_get_from_environment:
             # Check if session is still usable before processing each variable
@@ -54,8 +66,11 @@
 
                 # Skip placeholder/test values like "dummy" for API key variables only
                 # This prevents test environments from overwriting user-configured model provider keys
-                is_api_key_variable = var_name in var_to_provider
-                if is_api_key_variable and value.lower() == "dummy":
+                is_provider_variable = var_name in var_to_provider
+                var_info = var_to_info.get(var_name, {})
+                is_secret_variable = var_info.get("is_secret", False)
+
+                if is_provider_variable and is_secret_variable and value.lower() == "dummy":
                     await logger.adebug(
                         f"Skipping API key variable {var_name} with placeholder value 'dummy' "
                         "to preserve user configuration"
@@ -66,24 +81,32 @@
                 # Set default_fields if this is a known provider variable
                 default_fields = []
                 try:
-                    if is_api_key_variable:
+                    if is_provider_variable:
                         provider_name = var_to_provider[var_name]
-                        # Validate the API key before setting default_fields
+                        # Get the variable type from metadata
+                        var_display_name = var_info.get("variable_name", "api_key")
+
+                        # Validate secret variables (API keys) before setting default_fields
                         # This prevents invalid keys from enabling providers during migration
-                        try:
-                            from lfx.base.models.unified_models import validate_model_provider_key
-
-                            validate_model_provider_key(var_name, value)
-                            # Only set default_fields if validation passes
-                            default_fields = [provider_name, "api_key"]
-                            await logger.adebug(f"Validated {var_name} - provider will be enabled")
-                        except (ValueError, Exception) as validation_error:  # noqa: BLE001
-                            # Validation failed - don't set default_fields
-                            # This prevents the provider from appearing as "Enabled"
-                            default_fields = []
-                            await logger.adebug(
-                                f"Skipping default_fields for {var_name} - validation failed: {validation_error!s}"
-                            )
+                        if is_secret_variable:
+                            try:
+                                from lfx.base.models.unified_models import validate_model_provider_key
+
+                                validate_model_provider_key(var_name, value)
+                                # Only set default_fields if validation passes
+                                default_fields = [provider_name, var_display_name]
+                                await logger.adebug(f"Validated {var_name} - provider will be enabled")
+                            except (ValueError, Exception) as validation_error:  # noqa: BLE001
+                                # Validation failed - don't set default_fields
+                                # This prevents the provider from appearing as "Enabled"
+                                default_fields = []
+                                await logger.adebug(
+                                    f"Skipping default_fields for {var_name} - validation failed: {validation_error!s}"
+                                )
+                        else:
+                            # Non-secret variables (like project_id, url) don't need validation
+                            default_fields = [provider_name, var_display_name]
+                            await logger.adebug(f"Set default_fields for non-secret variable {var_name}")
                     existing = (await session.exec(query)).first()
                 except Exception as e:  # noqa: BLE001
                     await logger.aexception(f"Error querying {var_name} variable: {e!s}")

src/backend/tests/unit/api/v1/test_models_enabled_providers.py

@@ -400,3 +400,97 @@
         if variable.get("type") == CREDENTIAL_TYPE:
             # CRITICAL: Value must be None (redacted), never the original value
             assert variable["value"] is None
+
+
+@pytest.mark.usefixtures("active_user")
+async def test_provider_variable_mapping_returns_full_variable_info(client: AsyncClient, logged_in_headers):
+    """Test that provider-variable-mapping endpoint returns full variable info for each provider."""
+    response = await client.get("api/v1/models/provider-variable-mapping", headers=logged_in_headers)
+    result = response.json()
+
+    assert response.status_code == status.HTTP_200_OK
+    assert isinstance(result, dict)
+
+    # Check that known providers exist
+    assert "OpenAI" in result
+    assert "Anthropic" in result
+    assert "Google Generative AI" in result
+    assert "Ollama" in result
+    assert "IBM WatsonX" in result
+
+    # Check structure of variables for OpenAI (single variable provider)
+    openai_vars = result["OpenAI"]
+    assert isinstance(openai_vars, list)
+    assert len(openai_vars) >= 1
+
+    # Check each variable has required fields
+    for var in openai_vars:
+        assert "variable_name" in var
+        assert "variable_key" in var
+        assert "description" in var
+        assert "required" in var
+        assert "is_secret" in var
+        assert "is_list" in var
+        assert "options" in var
+
+    # Check OpenAI primary variable
+    openai_api_key_var = openai_vars[0]
+    assert openai_api_key_var["variable_key"] == "OPENAI_API_KEY"
+    assert openai_api_key_var["required"] is True
+    assert openai_api_key_var["is_secret"] is True
+
+
+@pytest.mark.usefixtures("active_user")
+async def test_provider_variable_mapping_multi_variable_provider(client: AsyncClient, logged_in_headers):
+    """Test that IBM WatsonX returns multiple required variables."""
+    response = await client.get("api/v1/models/provider-variable-mapping", headers=logged_in_headers)
+    result = response.json()
+
+    assert response.status_code == status.HTTP_200_OK
+
+    # Check IBM WatsonX has multiple variables
+    watsonx_vars = result.get("IBM WatsonX", [])
+    assert len(watsonx_vars) >= 3  # API Key, Project ID, URL
+
+    # Find each variable
+    var_keys = {v["variable_key"] for v in watsonx_vars}
+    assert "WATSONX_APIKEY" in var_keys
+    assert "WATSONX_PROJECT_ID" in var_keys
+    assert "WATSONX_URL" in var_keys
+
+    # Check API Key is secret
+    api_key_var = next((v for v in watsonx_vars if v["variable_key"] == "WATSONX_APIKEY"), None)
+    assert api_key_var is not None
+    assert api_key_var["is_secret"] is True
+    assert api_key_var["required"] is True
+
+    # Check Project ID is not secret
+    project_id_var = next((v for v in watsonx_vars if v["variable_key"] == "WATSONX_PROJECT_ID"), None)
+    assert project_id_var is not None
+    assert project_id_var["is_secret"] is False
+    assert project_id_var["required"] is True
+
+    # Check URL has options
+    url_var = next((v for v in watsonx_vars if v["variable_key"] == "WATSONX_URL"), None)
+    assert url_var is not None
+    assert url_var["is_secret"] is False
+    assert url_var["required"] is True
+    assert len(url_var["options"]) > 0  # Should have regional endpoint options
+    assert "https://us-south.ml.cloud.ibm.com" in url_var["options"]
+
+
+@pytest.mark.usefixtures("active_user")
+async def test_backward_compatible_variable_mapping(client: AsyncClient, logged_in_headers):
+    """Test that get_model_provider_variable_mapping() still returns primary variable (backward compat)."""
+    from lfx.base.models.unified_models import get_model_provider_variable_mapping
+
+    mapping = get_model_provider_variable_mapping()
+
+    # Should return dict of provider -> primary variable key
+    assert isinstance(mapping, dict)
+    assert mapping.get("OpenAI") == "OPENAI_API_KEY"
+    assert mapping.get("Anthropic") == "ANTHROPIC_API_KEY"
+    assert mapping.get("Google Generative AI") == "GOOGLE_API_KEY"
+    assert mapping.get("Ollama") == "OLLAMA_BASE_URL"
+    # IBM WatsonX should return primary secret (API key)
+    assert mapping.get("IBM WatsonX") == "WATSONX_APIKEY"