feat(agentics): Refactor bundle components to agenerate/amap/areduce pattern for Langflow 1.9 (#12518)

Co-authored-by: Alfio Gliozzo <gliozzo@us.ibm.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: 3 people

src/backend/tests/unit/agentic/services/test_provider_service.py

@@ -198,10 +198,7 @@ async def test_should_return_empty_when_no_credentials(self):
 
         mock_session = MagicMock()
 
-        with (
-            patch("langflow.agentic.services.provider_service.get_variable_service", return_value=mock_db_service),
-            patch("langflow.agentic.services.provider_service.os.getenv", return_value=None),
-        ):
+        with patch("langflow.agentic.services.provider_service.get_variable_service", return_value=mock_db_service):
             enabled_providers, provider_status = await get_enabled_providers_for_user("user-1", mock_session)
 
         assert enabled_providers == []
@@ -228,7 +225,6 @@ async def test_should_return_enabled_providers_with_credentials(self):
                 "langflow.agentic.services.provider_service.get_model_provider_variable_mapping",
                 return_value={"Anthropic": "ANTHROPIC_API_KEY", "OpenAI": "OPENAI_API_KEY"},
             ),
-            patch("langflow.agentic.services.provider_service.os.getenv", return_value=None),
         ):
             enabled, status = await get_enabled_providers_for_user("user-1", mock_session)
 
@@ -276,10 +272,7 @@ async def test_should_return_empty_when_get_all_returns_empty(self):
 
         mock_session = MagicMock()
 
-        with (
-            patch("langflow.agentic.services.provider_service.get_variable_service", return_value=mock_db_service),
-            patch("langflow.agentic.services.provider_service.os.getenv", return_value=None),
-        ):
+        with patch("langflow.agentic.services.provider_service.get_variable_service", return_value=mock_db_service):
             enabled_providers, provider_status = await get_enabled_providers_for_user("user-1", mock_session)
 
         assert enabled_providers == []

src/backend/tests/unit/components/bundles/agentics/test_agentics_component.py

@@ -10,7 +10,7 @@
 except ImportError:
     pytest.skip("agentics-py and crewai not installed", allow_module_level=True)
 
-from lfx.components.agentics import SemanticAggregator, SemanticMap, SyntheticDataGenerator
+from lfx.components.agentics import AgenerateComponent, AMapComponent, AreduceComponent
 from lfx.components.agentics.constants import (
     TRANSDUCTION_AMAP,
     TRANSDUCTION_AREDUCE,
@@ -20,25 +20,25 @@
 
 
 @pytest.mark.unit
-class TestSemanticMapComponent:
-    """Tests for SemanticMap (aMap) component metadata."""
+class TestAMapComponent:
+    """Tests for AMapComponent (aMap) component metadata."""
 
     def test_should_have_correct_display_name(self):
         """Test that component has correct display name."""
-        assert SemanticMap.display_name == "aMap"
+        assert AMapComponent.display_name == "aMap"
 
     def test_should_have_correct_icon(self):
         """Test that component has correct icon."""
-        assert SemanticMap.icon == "Agentics"
+        assert AMapComponent.icon == "Agentics"
 
     def test_should_have_correct_description(self):
         """Test that component has correct description."""
-        assert "augment" in SemanticMap.description.lower()
-        assert "dataframe" in SemanticMap.description.lower()
+        assert "augment" in AMapComponent.description.lower()
+        assert "dataframe" in AMapComponent.description.lower()
 
     def test_should_have_required_inputs(self):
         """Test that component has all required inputs."""
-        input_names = {i.name for i in SemanticMap.inputs}
+        input_names = {i.name for i in AMapComponent.inputs}
 
         assert "model" in input_names
         assert "api_key" in input_names
@@ -48,12 +48,12 @@ def test_should_have_required_inputs(self):
 
     def test_should_have_dataframe_output(self):
         """Test that component has DataFrame output."""
-        output_names = {o.name for o in SemanticMap.outputs}
+        output_names = {o.name for o in AMapComponent.outputs}
         assert "states" in output_names
 
     def test_should_have_provider_specific_inputs(self):
         """Test that component has provider-specific inputs."""
-        input_names = {i.name for i in SemanticMap.inputs}
+        input_names = {i.name for i in AMapComponent.inputs}
 
         assert "base_url_ibm_watsonx" in input_names
         assert "project_id" in input_names
@@ -67,13 +67,13 @@ def test_should_have_valid_transduction_constants(self):
 
     def test_should_have_model_input_with_real_time_refresh(self):
         """Test that model input has real_time_refresh enabled."""
-        model_input = next((i for i in SemanticMap.inputs if i.name == "model"), None)
+        model_input = next((i for i in AMapComponent.inputs if i.name == "model"), None)
         assert model_input is not None
         assert model_input.real_time_refresh is True
 
     def test_should_have_schema_input_with_table_schema(self):
         """Test that schema input has table_schema defined."""
-        schema_input = next((i for i in SemanticMap.inputs if i.name == "schema"), None)
+        schema_input = next((i for i in AMapComponent.inputs if i.name == "schema"), None)
         assert schema_input is not None
         assert schema_input.table_schema is not None
         assert len(schema_input.table_schema) > 0
@@ -86,20 +86,20 @@ def test_should_have_schema_input_with_table_schema(self):
 
 
 @pytest.mark.unit
-class TestSemanticAggregatorComponent:
-    """Tests for SemanticAggregator (aReduce) component metadata."""
+class TestAreduceComponent:
+    """Tests for AreduceComponent (aReduce) component metadata."""
 
     def test_should_have_correct_display_name(self):
         """Test that component has correct display name."""
-        assert SemanticAggregator.display_name == "aReduce"
+        assert AreduceComponent.display_name == "aReduce"
 
     def test_should_have_correct_icon(self):
         """Test that component has correct icon."""
-        assert SemanticAggregator.icon == "Agentics"
+        assert AreduceComponent.icon == "Agentics"
 
     def test_should_have_required_inputs(self):
         """Test that component has all required inputs."""
-        input_names = {i.name for i in SemanticAggregator.inputs}
+        input_names = {i.name for i in AreduceComponent.inputs}
 
         assert "model" in input_names
         assert "api_key" in input_names
@@ -108,30 +108,30 @@ def test_should_have_required_inputs(self):
 
     def test_should_have_states_output(self):
         """Test that component has states output."""
-        output_names = {o.name for o in SemanticAggregator.outputs}
+        output_names = {o.name for o in AreduceComponent.outputs}
         assert "states" in output_names
 
 
 @pytest.mark.unit
-class TestSyntheticDataGeneratorComponent:
-    """Tests for SyntheticDataGenerator (aGenerate) component metadata."""
+class TestAgenerateComponent:
+    """Tests for AgenerateComponent (aGenerate) component metadata."""
 
     def test_should_have_correct_display_name(self):
         """Test that component has correct display name."""
-        assert SyntheticDataGenerator.display_name == "aGenerate"
+        assert AgenerateComponent.display_name == "aGenerate"
 
     def test_should_have_correct_icon(self):
         """Test that component has correct icon."""
-        assert SyntheticDataGenerator.icon == "Agentics"
+        assert AgenerateComponent.icon == "Agentics"
 
     def test_should_have_batch_size_input(self):
         """Test that component has batch_size input."""
-        input_names = {i.name for i in SyntheticDataGenerator.inputs}
+        input_names = {i.name for i in AgenerateComponent.inputs}
         assert "batch_size" in input_names
 
     def test_should_have_states_output(self):
         """Test that component has states output."""
-        output_names = {o.name for o in SyntheticDataGenerator.outputs}
+        output_names = {o.name for o in AgenerateComponent.outputs}
         assert "states" in output_names
 
 

src/backend/tests/unit/components/bundles/agentics/test_semantic_aggregator.py

@@ -1,4 +1,4 @@
-"""Unit tests for Agentics SemanticAggregator component."""
+"""Unit tests for Agentics AreduceComponent (formerly SemanticAggregator)."""
 
 from __future__ import annotations
 
@@ -10,29 +10,29 @@
 except ImportError:
     pytest.skip("agentics-py and crewai not installed", allow_module_level=True)
 
-from lfx.components.agentics.semantic_aggregator import SemanticAggregator
+from lfx.components.agentics.areduce_component import AreduceComponent
 
 
 @pytest.mark.unit
-class TestSemanticAggregatorComponent:
-    """Tests for SemanticAggregator component metadata."""
+class TestAreduceComponent:
+    """Tests for AreduceComponent metadata."""
 
     def test_should_have_correct_display_name(self):
         """Test that component has correct display name."""
-        assert SemanticAggregator.display_name == "aReduce"
+        assert AreduceComponent.display_name == "aReduce"
 
     def test_should_have_correct_icon(self):
         """Test that component has correct icon."""
-        assert SemanticAggregator.icon == "Agentics"
+        assert AreduceComponent.icon == "Agentics"
 
     def test_should_have_correct_description(self):
         """Test that component has correct description."""
-        assert "dataframe" in SemanticAggregator.description.lower()
-        assert "schema" in SemanticAggregator.description.lower()
+        assert "dataframe" in AreduceComponent.description.lower()
+        assert "schema" in AreduceComponent.description.lower()
 
     def test_should_have_required_inputs(self):
         """Test that component has all required inputs."""
-        input_names = {i.name for i in SemanticAggregator.inputs}
+        input_names = {i.name for i in AreduceComponent.inputs}
 
         assert "model" in input_names
         assert "api_key" in input_names
@@ -42,26 +42,26 @@ def test_should_have_required_inputs(self):
 
     def test_should_have_dataframe_output(self):
         """Test that component has DataFrame output."""
-        output_names = {o.name for o in SemanticAggregator.outputs}
+        output_names = {o.name for o in AreduceComponent.outputs}
         assert "states" in output_names
 
     def test_should_have_provider_specific_inputs(self):
         """Test that component has provider-specific inputs."""
-        input_names = {i.name for i in SemanticAggregator.inputs}
+        input_names = {i.name for i in AreduceComponent.inputs}
 
         assert "base_url_ibm_watsonx" in input_names
         assert "project_id" in input_names
         assert "ollama_base_url" in input_names
 
     def test_should_have_model_input_with_real_time_refresh(self):
         """Test that model input has real_time_refresh enabled."""
-        model_input = next((i for i in SemanticAggregator.inputs if i.name == "model"), None)
+        model_input = next((i for i in AreduceComponent.inputs if i.name == "model"), None)
         assert model_input is not None
         assert model_input.real_time_refresh is True
 
     def test_should_have_schema_with_table_schema(self):
         """Test that schema input has table_schema defined."""
-        schema_input = next((i for i in SemanticAggregator.inputs if i.name == "schema"), None)
+        schema_input = next((i for i in AreduceComponent.inputs if i.name == "schema"), None)
         assert schema_input is not None
         assert schema_input.table_schema is not None
         assert len(schema_input.table_schema) > 0
@@ -74,18 +74,18 @@ def test_should_have_schema_with_table_schema(self):
 
     def test_should_have_api_key_as_advanced(self):
         """Test that api_key input is marked as advanced."""
-        api_key_input = next((i for i in SemanticAggregator.inputs if i.name == "api_key"), None)
+        api_key_input = next((i for i in AreduceComponent.inputs if i.name == "api_key"), None)
         assert api_key_input is not None
         assert api_key_input.advanced is True
 
     def test_should_have_source_as_required(self):
         """Test that source input is marked as required."""
-        source_input = next((i for i in SemanticAggregator.inputs if i.name == "source"), None)
+        source_input = next((i for i in AreduceComponent.inputs if i.name == "source"), None)
         assert source_input is not None
         assert source_input.required is True
 
     def test_should_have_output_with_correct_method(self):
         """Test that output has correct method name."""
-        output = next((o for o in SemanticAggregator.outputs if o.name == "states"), None)
+        output = next((o for o in AreduceComponent.outputs if o.name == "states"), None)
         assert output is not None
         assert output.method == "aReduce"

src/backend/tests/unit/components/bundles/agentics/test_semantic_map.py

@@ -1,4 +1,4 @@
-"""Unit tests for Agentics SemanticMap component."""
+"""Unit tests for Agentics AMapComponent (formerly SemanticMap)."""
 
 from __future__ import annotations
 
@@ -10,24 +10,24 @@
 except ImportError:
     pytest.skip("agentics-py and crewai not installed", allow_module_level=True)
 
-from lfx.components.agentics.semantic_map import SemanticMap
+from lfx.components.agentics.amap_component import AMapComponent
 
 
 @pytest.mark.unit
-class TestSemanticMapComponent:
-    """Tests for SemanticMap component metadata."""
+class TestAMapComponent:
+    """Tests for AMapComponent metadata."""
 
     def test_should_have_correct_display_name(self):
         """Test that component has correct display name."""
-        assert SemanticMap.display_name == "aMap"
+        assert AMapComponent.display_name == "aMap"
 
     def test_should_have_correct_icon(self):
         """Test that component has correct icon."""
-        assert SemanticMap.icon == "Agentics"
+        assert AMapComponent.icon == "Agentics"
 
     def test_should_have_required_inputs(self):
         """Test that component has all required inputs."""
-        input_names = {i.name for i in SemanticMap.inputs}
+        input_names = {i.name for i in AMapComponent.inputs}
 
         assert "model" in input_names
         assert "api_key" in input_names
@@ -38,26 +38,26 @@ def test_should_have_required_inputs(self):
 
     def test_should_have_dataframe_output(self):
         """Test that component has DataFrame output."""
-        output_names = {o.name for o in SemanticMap.outputs}
+        output_names = {o.name for o in AMapComponent.outputs}
         assert "states" in output_names
 
     def test_should_have_provider_specific_inputs(self):
         """Test that component has provider-specific inputs."""
-        input_names = {i.name for i in SemanticMap.inputs}
+        input_names = {i.name for i in AMapComponent.inputs}
 
         assert "base_url_ibm_watsonx" in input_names
         assert "project_id" in input_names
         assert "ollama_base_url" in input_names
 
     def test_should_have_model_input_with_real_time_refresh(self):
         """Test that model input has real_time_refresh enabled."""
-        model_input = next((i for i in SemanticMap.inputs if i.name == "model"), None)
+        model_input = next((i for i in AMapComponent.inputs if i.name == "model"), None)
         assert model_input is not None
         assert model_input.real_time_refresh is True
 
     def test_should_have_schema_with_table_schema(self):
         """Test that schema input has table_schema defined."""
-        schema_input = next((i for i in SemanticMap.inputs if i.name == "schema"), None)
+        schema_input = next((i for i in AMapComponent.inputs if i.name == "schema"), None)
         assert schema_input is not None
         assert schema_input.table_schema is not None
         assert len(schema_input.table_schema) > 0
@@ -70,6 +70,6 @@ def test_should_have_schema_with_table_schema(self):
 
     def test_should_have_append_to_input_columns_as_boolean(self):
         """Test that append_to_input_columns input is a boolean."""
-        append_input = next((i for i in SemanticMap.inputs if i.name == "append_to_input_columns"), None)
+        append_input = next((i for i in AMapComponent.inputs if i.name == "append_to_input_columns"), None)
         assert append_input is not None
         assert append_input.value is True