fix(providers/standard): remove premature param value validation in HITLOperator

HITLOperator params are form fields filled by a human at runtime. Calling
`self.params.validate()` in `__init__` incorrectly validates param values at
DAG parse time, before any human input exists. This causes `ParamValidationError`
for any param without an explicit default value, breaking DAG import.

The fix removes `self.params.validate()` from `validate_params()`. Value
validation (type, required fields, schema) already happens correctly in
`validate_params_input()` after the human submits the form.

The `_options` key check is preserved — it is a structural constraint, not
a value check.

Closes #59551

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Author: antonio-mello-ai

providers/standard/src/airflow/providers/standard/operators/hitl.py

@@ -147,10 +147,15 @@ def validate_params(self) -> None:
         """
         Validate the `params` attribute of the instance.
 
+        Note: Value validation (e.g., required fields, schema) is intentionally skipped here
+        because HITLOperator params represent form fields that are filled by a human at runtime.
+        Values do not exist at DAG parse time, so validating them in ``__init__`` would cause
+        a ``ParamValidationError`` for any param without a default. Value validation happens
+        in ``validate_params_input`` after the human submits the form.
+
         Raises:
-            ValueError: If `"_options"` key is present in `params`, which is not allowed.
+            ValueError: If ``"_options"`` key is present in ``params``, which is not allowed.
         """
-        self.params.validate()
         if "_options" in self.params:
             raise ValueError('"_options" is not allowed in params')
 

providers/standard/tests/unit/standard/operators/test_hitl.py

@@ -139,37 +139,67 @@ def test_validate_options_with_empty_options(self) -> None:
                 params=ParamsDict({"input_1": 1}),
             )
 
-    @pytest.mark.parametrize(
-        ("params", "exc", "error_msg"),
-        (
-            (ParamsDict({"_options": 1}), ValueError, '"_options" is not allowed in params'),
-            (
-                ParamsDict({"param": Param("", type="integer")}),
-                ParamValidationError,
-                (
-                    "Invalid input for param param: '' is not of type 'integer'\n\n"
-                    "Failed validating 'type' in schema:\n"
-                    "    {'type': 'integer'}\n\n"
-                    "On instance:\n    ''"
-                ),
-            ),
-        ),
-    )
-    def test_validate_params(
-        self, params: ParamsDict, exc: type[ValueError | ParamValidationError], error_msg: str
-    ) -> None:
-        # validate_params is called during initialization
-        with pytest.raises(exc, match=error_msg):
+    def test_validate_params_rejects_options_key(self) -> None:
+        """_options is a reserved key and must not be allowed in params."""
+        with pytest.raises(ValueError, match='"_options" is not allowed in params'):
             HITLOperator(
                 task_id="hitl_test",
                 subject="This is subject",
                 options=["1", "2"],
                 body="This is body",
                 defaults=["1"],
                 multiple=False,
-                params=params,
+                params=ParamsDict({"_options": 1}),
             )
 
+    def test_param_without_default_does_not_raise_on_init(self) -> None:
+        """Regression test for #59551.
+
+        HITLOperator params are form fields filled by a human at runtime. A param with no
+        default value is valid — the human provides the value when submitting the form.
+        Validating param values in __init__ incorrectly raises ParamValidationError at DAG
+        parse time, before any value exists.
+        """
+        # Must not raise ParamValidationError
+        op = HITLOperator(
+            task_id="hitl_test",
+            subject="This is subject",
+            options=["1", "2"],
+            body="This is body",
+            defaults=["1"],
+            multiple=False,
+            params={"my_param": Param(type="string")},
+        )
+        assert "my_param" in op.params
+
+    def test_param_with_default_does_not_raise_on_init(self) -> None:
+        """Params with explicit defaults continue to work normally."""
+        op = HITLOperator(
+            task_id="hitl_test",
+            subject="This is subject",
+            options=["1", "2"],
+            body="This is body",
+            defaults=["1"],
+            multiple=False,
+            params={"my_param": Param("hello", type="string")},
+        )
+        assert "my_param" in op.params
+
+    def test_param_with_wrong_value_type_does_not_raise_on_init(self) -> None:
+        """Value validation is deferred to validate_params_input at runtime, not __init__."""
+        # Param("", type="integer") has a value that doesn't match the schema, but
+        # this must NOT raise at init time — the human will provide the correct value at runtime.
+        op = HITLOperator(
+            task_id="hitl_test",
+            subject="This is subject",
+            options=["1", "2"],
+            body="This is body",
+            defaults=["1"],
+            multiple=False,
+            params={"param": Param("", type="integer")},
+        )
+        assert "param" in op.params
+
     def test_validate_defaults(self) -> None:
         hitl_op = HITLOperator(
             task_id="hitl_test",