Tool mode and ruff fixes

src/backend/tests/unit/components/data/test_file_component.py

@@ -186,3 +186,43 @@ def test_dynamic_outputs_have_tool_mode_enabled(self):
         result = component.update_outputs(frontend_node, "advanced_mode", field_value=False)
         for output in result["outputs"]:
             assert output.tool_mode is True, f"Output {output.name} should have tool_mode=True"
+
+    def test_file_path_str_input_exists_for_tool_mode(self):
+        """Test that file_path_str input exists for tool mode."""
+        component = FileComponent()
+
+        # Find the file_path_str input
+        file_path_str_input = None
+        for input_field in component.inputs:
+            if input_field.name == "file_path_str":
+                file_path_str_input = input_field
+                break
+
+        assert file_path_str_input is not None, "file_path_str input should exist"
+        assert file_path_str_input.tool_mode is True, "file_path_str should have tool_mode=True"
+
+        # Check that the path FileInput has tool_mode=False
+        path_input = None
+        for input_field in component.inputs:
+            if input_field.name == "path":
+                path_input = input_field
+                break
+
+        assert path_input is not None, "path input should exist"
+        assert path_input.tool_mode is False, "path FileInput should have tool_mode=False"
+
+    def test_read_file_using_file_path_str(self, tmp_path):
+        """Test reading a file using file_path_str parameter (tool mode)."""
+        # Create a test file
+        test_file = tmp_path / "test.txt"
+        test_content = "Hello from tool mode!"
+        test_file.write_text(test_content)
+
+        # Create component and set file_path_str
+        component = FileComponent()
+        component.file_path_str = str(test_file)
+
+        # Load the file
+        result = component.load_files_message()
+
+        assert result.text == test_content, f"Expected '{test_content}', got '{result.text}'"

src/lfx/src/lfx/components/data/file.py

@@ -70,10 +70,19 @@ class FileComponent(BaseFileComponent):
     for input_item in _base_inputs:
         if isinstance(input_item, FileInput) and input_item.name == "path":
             input_item.real_time_refresh = True
+            input_item.tool_mode = False  # Disable tool mode for file upload input
             break
 
     inputs = [
         *_base_inputs,
+        StrInput(
+            name="file_path_str",
+            display_name="File Path",
+            info="Path to the file to read. Used when component is called as a tool.",
+            show=False,
+            advanced=True,
+            tool_mode=True,
+        ),
         BoolInput(
             name="advanced_mode",
             display_name="Advanced Parser",
@@ -260,6 +269,41 @@ def update_outputs(self, frontend_node: dict[str, Any], field_name: str, field_v
 
     # ------------------------------ Core processing ----------------------------------
 
+    def _validate_and_resolve_paths(self) -> list[BaseFileComponent.BaseFile]:
+        """Override to handle file_path_str input from tool mode.
+
+        When called as a tool, the file_path_str parameter will be set,
+        and we should use that instead of the path FileInput.
+        """
+        # Check if file_path_str is provided (from tool mode)
+        # file_path_str will be set when component is called as a tool
+        file_path_str = getattr(self, "file_path_str", None)
+        if file_path_str:
+            # Use the string path from tool mode
+            from pathlib import Path
+
+            from lfx.schema.data import Data
+
+            resolved_path = Path(self.resolve_path(file_path_str))
+            if not resolved_path.exists():
+                msg = f"File or directory not found: {file_path_str}"
+                self.log(msg)
+                if not self.silent_errors:
+                    raise ValueError(msg)
+                return []
+
+            data_obj = Data(data={self.SERVER_FILE_PATH_FIELDNAME: str(resolved_path)})
+            return [
+                BaseFileComponent.BaseFile(
+                    data_obj,
+                    resolved_path,
+                    delete_after_processing=False
+                )
+            ]
+
+        # Otherwise use the default implementation
+        return super()._validate_and_resolve_paths()
+
     def _is_docling_compatible(self, file_path: str) -> bool:
         """Lightweight extension gate for Docling-compatible types."""
         docling_exts = (