feat: fix cuga component with new release

pyproject.toml

@@ -134,7 +134,7 @@ dependencies = [
     "fastparquet>=2024.11.0,<2025.0.0",
     "traceloop-sdk>=0.43.1,<1.0.0",
     "vlmrun[all]>=0.2.0",
-    "cuga==0.1.7",
+    "cuga==0.1.8",
     "agent-lifecycle-toolkit~=0.4.1",
     "astrapy>=2.1.0,<3.0.0",
 ]

src/backend/tests/unit/components/models_and_agents/test_agent_component.py

@@ -109,261 +109,6 @@ async def test_build_config_update(self, component_class, default_kwargs):
         # Verify model_name field is cleared for Custom
         assert "model_name" not in updated_config
 
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_agent_has_dual_outputs(self, component_class, default_kwargs):
-        """Test that Agent component has both Response and Structured Response outputs."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        assert len(component.outputs) == 2
-        assert component.outputs[0].name == "response"
-        assert component.outputs[0].display_name == "Response"
-        assert component.outputs[0].method == "message_response"
-
-        assert component.outputs[1].name == "structured_response"
-        assert component.outputs[1].display_name == "Structured Response"
-        assert component.outputs[1].method == "json_response"
-        assert component.outputs[1].tool_mode is False
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_json_mode_filtered_from_openai_inputs(self, component_class, default_kwargs):
-        """Test that json_mode is filtered out from OpenAI inputs."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        # Check that json_mode is not in the agent's inputs
-        input_names = [inp.name for inp in component.inputs if hasattr(inp, "name")]
-        assert "json_mode" not in input_names
-
-        # Verify other OpenAI inputs are still present
-        assert "model_name" in input_names
-        assert "api_key" in input_names
-        assert "temperature" in input_names
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_json_response_parsing_valid_json(self, component_class, default_kwargs):
-        """Test that json_response correctly parses JSON from agent response."""
-        component = await self.component_setup(component_class, default_kwargs)
-        # Mock the get_agent_requirements method to avoid actual LLM calls
-        from unittest.mock import AsyncMock
-
-        component.get_agent_requirements = AsyncMock(return_value=(MockLanguageModel(), [], []))
-        component.create_agent_runnable = AsyncMock(return_value=None)
-        mock_result = type("MockResult", (), {"content": '{"name": "test", "value": 123}'})()
-        component.run_agent = AsyncMock(return_value=mock_result)
-
-        result = await component.json_response()
-
-        from lfx.schema.data import Data
-
-        assert isinstance(result, Data)
-        assert result.data == {"name": "test", "value": 123}
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_json_response_parsing_embedded_json(self, component_class, default_kwargs):
-        """Test that json_response handles text containing JSON."""
-        component = await self.component_setup(component_class, default_kwargs)
-        # Mock the get_agent_requirements method to avoid actual LLM calls
-        from unittest.mock import AsyncMock
-
-        component.get_agent_requirements = AsyncMock(return_value=(MockLanguageModel(), [], []))
-        component.create_agent_runnable = AsyncMock(return_value=None)
-        mock_result = type("MockResult", (), {"content": 'Here is the result: {"status": "success"} - done!'})()
-        component.run_agent = AsyncMock(return_value=mock_result)
-
-        result = await component.json_response()
-
-        from lfx.schema.data import Data
-
-        assert isinstance(result, Data)
-        assert result.data == {"status": "success"}
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_json_response_error_handling(self, component_class, default_kwargs):
-        """Test that json_response handles completely non-JSON responses."""
-        component = await self.component_setup(component_class, default_kwargs)
-        # Mock the get_agent_requirements method to avoid actual LLM calls
-        from unittest.mock import AsyncMock
-
-        component.get_agent_requirements = AsyncMock(return_value=(MockLanguageModel(), [], []))
-        component.create_agent_runnable = AsyncMock(return_value=None)
-        mock_result = type("MockResult", (), {"content": "This is just plain text with no JSON"})()
-        component.run_agent = AsyncMock(return_value=mock_result)
-
-        result = await component.json_response()
-
-        from lfx.schema.data import Data
-
-        assert isinstance(result, Data)
-        assert "error" in result.data
-        assert result.data["content"] == "This is just plain text with no JSON"
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_model_building_without_json_mode(self, component_class, default_kwargs):
-        """Test that model building works without json_mode attribute."""
-        component = await self.component_setup(component_class, default_kwargs)
-        component.agent_llm = "OpenAI"
-
-        # Mock component for testing
-        from unittest.mock import Mock
-
-        mock_component = Mock()
-        mock_component.set.return_value = mock_component
-
-        # Should not raise AttributeError for missing json_mode
-        result = component.set_component_params(mock_component)
-
-        assert result is not None
-        # Verify set was called (meaning no AttributeError occurred)
-        mock_component.set.assert_called_once()
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_json_response_with_schema_validation(self, component_class, default_kwargs):
-        """Test that json_response validates against provided schema."""
-        # Set up component with output schema
-        default_kwargs["output_schema"] = [
-            {"name": "name", "type": "str", "description": "Name field", "multiple": False},
-            {"name": "age", "type": "int", "description": "Age field", "multiple": False},
-        ]
-        component = await self.component_setup(component_class, default_kwargs)
-        # Mock the get_agent_requirements method
-        from unittest.mock import AsyncMock
-
-        component.get_agent_requirements = AsyncMock(return_value=(MockLanguageModel(), [], []))
-        component.create_agent_runnable = AsyncMock(return_value=None)
-        mock_result = type("MockResult", (), {"content": '{"name": "John", "age": 25}'})()
-        component.run_agent = AsyncMock(return_value=mock_result)
-
-        result = await component.json_response()
-
-        from langflow.schema.data import Data
-
-        assert isinstance(result, Data)
-        assert result.data == {"name": "John", "age": 25}
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_agent_component_initialization(self, component_class, default_kwargs):
-        """Test that Agent component initializes correctly with filtered inputs."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        # Should not raise any errors during initialization
-        assert component.display_name == "Agent"
-        assert component.name == "Agent"
-        assert len(component.inputs) > 0
-        assert len(component.outputs) == 2
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_frontend_node_structure(self, component_class, default_kwargs):
-        """Test that frontend node has correct structure with filtered inputs."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        frontend_node = component.to_frontend_node()
-        build_config = frontend_node["data"]["node"]["template"]
-
-        # Verify json_mode is not in build config
-        assert "json_mode" not in build_config
-
-        # Verify other expected fields are present
-        assert "agent_llm" in build_config
-        assert "system_prompt" in build_config
-        assert "add_current_date_tool" in build_config
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_preprocess_schema(self, component_class, default_kwargs):
-        """Test that _preprocess_schema correctly handles schema validation."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        # Test schema preprocessing
-        raw_schema = [
-            {"name": "field1", "type": "str", "description": "Test field", "multiple": "true"},
-            {"name": "field2", "type": "int", "description": "Another field", "multiple": False},
-        ]
-
-        processed = component._preprocess_schema(raw_schema)
-
-        assert len(processed) == 2
-        assert processed[0]["multiple"] is True  # String "true" should be converted to bool
-        assert processed[1]["multiple"] is False
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_build_structured_output_base_with_validation(self, component_class, default_kwargs):
-        """Test build_structured_output_base with schema validation."""
-        default_kwargs["output_schema"] = [
-            {"name": "name", "type": "str", "description": "Name field", "multiple": False},
-            {"name": "count", "type": "int", "description": "Count field", "multiple": False},
-        ]
-        component = await self.component_setup(component_class, default_kwargs)
-
-        # Test valid JSON that matches schema
-        valid_content = '{"name": "test", "count": 42}'
-        result = await component.build_structured_output_base(valid_content)
-        assert result == [{"name": "test", "count": 42}]
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_build_structured_output_base_without_schema(self, component_class, default_kwargs):
-        """Test build_structured_output_base without schema validation."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        # Test with no output_schema
-        content = '{"any": "data", "number": 123}'
-        result = await component.build_structured_output_base(content)
-        assert result == {"any": "data", "number": 123}
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_build_structured_output_base_embedded_json(self, component_class, default_kwargs):
-        """Test extraction of JSON from embedded text."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        content = 'Here is some text with {"embedded": "json"} inside it.'
-        result = await component.build_structured_output_base(content)
-        assert result == {"embedded": "json"}
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_build_structured_output_base_no_json(self, component_class, default_kwargs):
-        """Test handling of content with no JSON."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        content = "This is just plain text with no JSON at all."
-        result = await component.build_structured_output_base(content)
-        assert "error" in result
-        assert result["content"] == content
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_new_input_fields_present(self, component_class, default_kwargs):
-        """Test that new input fields are present in the component."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        input_names = [inp.name for inp in component.inputs if hasattr(inp, "name")]
-
-        # Test for new fields
-        assert "format_instructions" in input_names
-        assert "output_schema" in input_names
-        assert "n_messages" in input_names
-
-        # Verify default values
-        assert hasattr(component, "format_instructions")
-        assert hasattr(component, "output_schema")
-        assert hasattr(component, "n_messages")
-        assert component.n_messages == 100
-
-    @pytest.mark.skip(reason="Test marked as skipped, agent dual output removed")
-    async def test_agent_has_correct_outputs(self, component_class, default_kwargs):
-        """Test that Agent component has the correct output configuration."""
-        component = await self.component_setup(component_class, default_kwargs)
-
-        assert len(component.outputs) == 2
-
-        # Test response output
-        response_output = component.outputs[0]
-        assert response_output.name == "response"
-        assert response_output.display_name == "Response"
-        assert response_output.method == "message_response"
-
-        # Test structured response output
-        structured_output = component.outputs[1]
-        assert structured_output.name == "structured_response"
-        assert structured_output.display_name == "Structured Response"
-        assert structured_output.method == "json_response"
-        assert structured_output.tool_mode is False
-
     async def test_agent_filters_empty_chat_history_messages(self):
         """Test that empty messages in chat history are filtered out."""
         from lfx.base.agents.utils import data_to_messages